rocksdb Namespace Reference

Namespaces
	anon
	crc32c
	log
	port
	stl_wrappers
	test

Classes
class	CorruptionTest
class	RandomGenerator
class	Stats
struct	SharedState
struct	ThreadState
class	Duration
class	Benchmark
struct	CompareLogByPointer
class	DBImpl
class	DBImplReadOnly
class	DBStatistics
class	SpecialEnv
class	DBTest
class	KeepFilter
class	DeleteFilter
class	ChangeFilter
class	KeepFilterFactory
class	DeleteFilterFactory
class	ChangeFilterFactory
class	ModelDB
struct	ParsedInternalKey
class	InternalKeyComparator
class	InternalFilterPolicy
class	InternalKey
class	LookupKey
class	FormatTest
class	DeleteFileTest
class	FileNameTest
class	MemTableIterator
class	MemTable
class	MemTableList
class	MergeHelper
class	PerfContextTest
class	PrefixFilterIterator
struct	TestKey
class	TestKeyComparator
class	PrefixTest
class	SimpleTableReader
class	SimpleTableIterator
class	SimpleTableBuilder
class	SimpleTableFactory
class	SimpleTableDBTest
class	SkipList
struct	TestComparator
class	SkipTest
class	ConcurrentTest
class	TestState
class	SnapshotImpl
class	SnapshotList
class	TableCache
struct	InternalKeyTablePropertiesNames
class	InternalKeyPropertiesCollector
class	UserKeyTablePropertiesCollector
class	TablePropertiesTest
class	FakeWritableFile
class	FakeRandomeAccessFile
class	DumbLogger
class	RegularKeysStartWithA
struct	LogReporter
class	LogFileImpl
class	TransactionLogIteratorImpl
struct	FileMetaData
class	VersionEdit
class	VersionEditTest
class	Version
class	VersionSet
class	Compaction
class	FindFileTest
class	WriteBatchInternal
class	WriteBatchTest
class	HdfsEnv
class	MemEnvTest
class	Arena
class	Cache
class	CompactionFilter
class	CompactionFilterFactory
class	DefaultCompactionFilterFactory
class	Comparator
struct	LiveFileMetaData
class	Snapshot
struct	Range
class	DB
struct	EnvOptions
class	Env
class	SequentialFile
class	RandomAccessFile
class	WritableFile
class	RandomRWFile
class	Logger
class	FileLock
class	EnvWrapper
class	FilterPolicy
class	FlushBlockPolicy
class	FlushBlockPolicyFactory
class	FlushBlockBySizePolicyFactory
class	Iterator
class	LDBTool
class	MemTableRep
class	MemTableRepFactory
class	VectorRepFactory
class	SkipListFactory
class	TransformRepFactory
class	UnsortedRepFactory
class	PrefixHashRepFactory
class	MergeOperator
class	AssociativeMergeOperator
struct	CompressionOptions
struct	Options
struct	ReadOptions
struct	WriteOptions
struct	FlushOptions
struct	PerfContext
class	Slice
struct	SliceParts
class	SliceTransform
struct	HistogramData
class	Histogram
class	Ticker
class	Statistics
class	Status
class	TableBuilder
class	TableReader
class	TableFactory
struct	TableProperties
class	TablePropertiesCollector
class	LogFile
struct	BatchResult
class	TransactionLogIterator
class	CompactionOptionsUniversal
class	WriteBatch
class	StackableDB
class	UtilityDB
class	Block
class	BlockBasedTableBuilder
class	BlockBasedTableFactory
class	BlockBasedTable
struct	BlockBasedTablePropertiesNames
class	BlockBuilder
class	BlockTest
class	FilterBlockBuilder
class	FilterBlockReader
class	TestHashFilter
class	FilterBlockTest
class	FlushBlockBySizePolicy
class	BlockHandle
class	Footer
struct	BlockContents
class	MaxIteratorComparator
class	MinIteratorComparator
class	IteratorWrapper
class	StringSink
class	StringSource
class	Constructor
class	BlockConstructor
class	BlockBasedTableConstructor
class	KeyConvertingIterator
class	MemTableConstructor
class	DBConstructor
struct	TestArgs
class	Harness
class	TableTest
class	BlockCacheProperties
class	MemTableTest
class	StressTest
class	ReduceLevelTest
class	DBClientProxy
class	SstFileReader
class	ArenaImpl
class	ArenaImplTest
class	AutoRollLogger
class	AutoRollLoggerTest
class	BitSet
struct	BlobChunk
struct	Blob
class	FreeList
class	BlobStore
class	BlobStoreTest
class	BloomTest
class	CacheTest
class	Value
class	Coding
class	EnvPosixTest
struct	State
class	LockTest
class	HashSkipListRepFactory
class	HistogramBucketMapper
class	HistogramImpl
class	HistogramTest
class	InMemoryHandler
class	LDBCommand
class	CompactorCommand
class	DBDumperCommand
class	InternalDumpCommand
class	DBLoaderCommand
class	ManifestDumpCommand
class	ReduceDBLevelsCommand
class	ChangeCompactionStyleCommand
class	WALDumperCommand
class	GetCommand
class	ApproxSizeCommand
class	BatchPutCommand
class	ScanCommand
class	DeleteCommand
class	PutCommand
class	DBQuerierCommand
class	LDBCommandExecuteResult
class	LDBCommandRunner
class	MutexLock
class	ReadLock
class	WriteLock
class	PosixLogger
class	Random
class	Random64
class	StatsLogger
class	StopWatch
class	StopWatchNano
class	StringAppendOperator
class	StringAppendTESTOperator
class	StringLists
class	StringAppendOperatorTest
class	MergeOperators
class	RedisListException
class	RedisListIterator
class	RedisLists
class	RedisListsTest
class	DBWithTTL
class	TtlIterator
class	TtlCompactionFilter
class	TtlCompactionFilterFactory
class	TtlMergeOperator
class	TtlTest

Typedefs
typedef uint64_t	Key
typedef std::vector < std::unique_ptr< LogFile > >	VectorLogPtr
typedef uint64_t	SequenceNumber
typedef std::priority_queue < IteratorWrapper *, std::vector < IteratorWrapper * > , MaxIteratorComparator >	MaxIterHeap
typedef std::priority_queue < IteratorWrapper *, std::vector < IteratorWrapper * > , MinIteratorComparator >	MinIterHeap
typedef std::map< std::string, std::string, anon::STLLessThan >	KVMap

Enumerations
enum	ValueType { kTypeDeletion = 0x0, kTypeValue = 0x1, kTypeMerge = 0x2, kTypeLogData = 0x3 }
enum	FileType {   kLogFile, kDBLockFile, kTableFile, kDescriptorFile,   kCurrentFile, kTempFile, kInfoLogFile, kMetaDatabase,   kIdentityFile }
enum	Tag {   kComparator = 1, kLogNumber = 2, kNextFileNumber = 3, kLastSequence = 4,   kCompactPointer = 5, kDeletedFile = 6, kNewFile = 7, kPrevLogNumber = 9,   kNewFile2 = 100 }
enum	CompressionType : char { kNoCompression = 0x0, kSnappyCompression = 0x1, kZlibCompression = 0x2, kBZip2Compression = 0x3 }
enum	CompactionStyle : char { kCompactionStyleLevel = 0x0, kCompactionStyleUniversal = 0x1 }
enum	ReadTier { kReadAllTier = 0x0, kBlockCacheTier = 0x1 }
enum	PerfLevel { kDisable = 0, kEnableCount = 1, kEnableTime = 2 }
enum	Tickers {   BLOCK_CACHE_MISS, BLOCK_CACHE_HIT, BLOCK_CACHE_ADD, BLOCK_CACHE_INDEX_MISS,   BLOCK_CACHE_INDEX_HIT, BLOCK_CACHE_FILTER_MISS, BLOCK_CACHE_FILTER_HIT, BLOCK_CACHE_DATA_MISS,   BLOCK_CACHE_DATA_HIT, BLOOM_FILTER_USEFUL, COMPACTION_KEY_DROP_NEWER_ENTRY, COMPACTION_KEY_DROP_OBSOLETE,   COMPACTION_KEY_DROP_USER, NUMBER_KEYS_WRITTEN, NUMBER_KEYS_READ, NUMBER_KEYS_UPDATED,   BYTES_WRITTEN, BYTES_READ, NO_FILE_CLOSES, NO_FILE_OPENS,   NO_FILE_ERRORS, STALL_L0_SLOWDOWN_MICROS, STALL_MEMTABLE_COMPACTION_MICROS, STALL_L0_NUM_FILES_MICROS,   RATE_LIMIT_DELAY_MILLIS, NO_ITERATORS, NUMBER_MULTIGET_CALLS, NUMBER_MULTIGET_KEYS_READ,   NUMBER_MULTIGET_BYTES_READ, NUMBER_FILTERED_DELETES, NUMBER_MERGE_FAILURES, SEQUENCE_NUMBER,   BLOOM_FILTER_PREFIX_CHECKED, BLOOM_FILTER_PREFIX_USEFUL, NUMBER_OF_RESEEKS_IN_ITERATION, GET_UPDATES_SINCE_CALLS,   BLOCK_CACHE_COMPRESSED_MISS, BLOCK_CACHE_COMPRESSED_HIT, TICKER_ENUM_MAX }
enum	Histograms {   DB_GET, DB_WRITE, COMPACTION_TIME, TABLE_SYNC_MICROS,   COMPACTION_OUTFILE_SYNC_MICROS, WAL_FILE_SYNC_MICROS, MANIFEST_FILE_SYNC_MICROS, TABLE_OPEN_IO_MICROS,   DB_MULTIGET, READ_BLOCK_COMPACTION_MICROS, READ_BLOCK_GET_MICROS, WRITE_RAW_BLOCK_MICROS,   STALL_L0_SLOWDOWN_COUNT, STALL_MEMTABLE_COMPACTION_COUNT, STALL_L0_NUM_FILES_COUNT, HARD_RATE_LIMIT_DELAY_COUNT,   SOFT_RATE_LIMIT_DELAY_COUNT, NUM_FILES_IN_SINGLE_COMPACTION, HISTOGRAM_ENUM_MAX }
enum	WalFileType { kArchivedLogFile = 0, kAliveLogFile = 1 }
enum	CompactionStopStyle { kCompactionStopStyleSimilarSize, kCompactionStopStyleTotalSize }
enum	TestType { TABLE_TEST, BLOCK_TEST, MEMTABLE_TEST, DB_TEST }

Functions
TableBuilder *	GetTableBuilder (const Options &options, WritableFile *file, CompressionType compression_type)
Status	BuildTable (const std::string &dbname, Env *env, const Options &options, const EnvOptions &soptions, TableCache *table_cache, Iterator *iter, FileMetaData *meta, const Comparator *user_comparator, const SequenceNumber newest_snapshot, const SequenceNumber earliest_seqno_in_memtable, const bool enable_compression)
	TEST (CorruptionTest, Recovery)
	TEST (CorruptionTest, RecoverWriteError)
	TEST (CorruptionTest, NewFileErrorDuringWrite)
	TEST (CorruptionTest, TableFile)
	TEST (CorruptionTest, TableFileIndexData)
	TEST (CorruptionTest, MissingDescriptor)
	TEST (CorruptionTest, SequenceNumberRecovery)
	TEST (CorruptionTest, CorruptedDescriptor)
	TEST (CorruptionTest, CompactionInputError)
	TEST (CorruptionTest, CompactionInputErrorParanoid)
	TEST (CorruptionTest, UnrelatedKeys)
static void	AppendWithSpace (std::string *str, Slice msg)
void	dumpLeveldbBuildVersion (Logger *log)
template<class T , class V >
static void	ClipToRange (T *ptr, V minvalue, V maxvalue)
Options	SanitizeOptions (const std::string &dbname, const InternalKeyComparator *icmp, const InternalFilterPolicy *ipolicy, const Options &src)
CompressionType	GetCompressionType (const Options &options, int level, const bool enable_compression)
Status	DestroyDB (const std::string &dbname, const Options &options)
Iterator *	NewDBIterator (const std::string *dbname, Env *env, const Options &options, const Comparator *user_key_comparator, Iterator *internal_iter, const SequenceNumber &sequence)
std::shared_ptr< Statistics >	CreateDBStatistics ()
static bool	SnappyCompressionSupported (const CompressionOptions &options)
static bool	ZlibCompressionSupported (const CompressionOptions &options)
static bool	BZip2CompressionSupported (const CompressionOptions &options)
static std::string	RandomString (Random *rnd, int len)
static std::string	Key (int i)
	TEST (DBTest, Empty)
	TEST (DBTest, ReadWrite)
	TEST (DBTest, IndexAndFilterBlocksOfNewTableAddedToCache)
	TEST (DBTest, LevelLimitReopen)
	TEST (DBTest, Preallocation)
	TEST (DBTest, PutDeleteGet)
	TEST (DBTest, GetFromImmutableLayer)
	TEST (DBTest, GetFromVersions)
	TEST (DBTest, GetSnapshot)
	TEST (DBTest, GetLevel0Ordering)
	TEST (DBTest, GetOrderedByLevels)
	TEST (DBTest, GetPicksCorrectFile)
	TEST (DBTest, GetEncountersEmptyLevel)
	TEST (DBTest, KeyMayExist)
	TEST (DBTest, NonBlockingIteration)
	TEST (DBTest, FilterDeletes)
	TEST (DBTest, IterEmpty)
	TEST (DBTest, IterSingle)
	TEST (DBTest, IterMulti)
	TEST (DBTest, IterReseek)
	TEST (DBTest, IterSmallAndLargeMix)
	TEST (DBTest, IterMultiWithDelete)
	TEST (DBTest, IterPrevMaxSkip)
	TEST (DBTest, IterWithSnapshot)
	TEST (DBTest, Recover)
	TEST (DBTest, RollLog)
	TEST (DBTest, WAL)
	TEST (DBTest, CheckLock)
	TEST (DBTest, FlushMultipleMemtable)
	TEST (DBTest, NumImmutableMemTable)
	TEST (DBTest, FLUSH)
	TEST (DBTest, RecoveryWithEmptyLog)
	TEST (DBTest, RecoverDuringMemtableCompaction)
	TEST (DBTest, MinorCompactionsHappen)
	TEST (DBTest, ManifestRollOver)
	TEST (DBTest, IdentityAcrossRestarts)
	TEST (DBTest, RecoverWithLargeLog)
	TEST (DBTest, CompactionsGenerateMultipleFiles)
	TEST (DBTest, CompactionTrigger)
	TEST (DBTest, UniversalCompactionTrigger)
	TEST (DBTest, UniversalCompactionSizeAmplification)
	TEST (DBTest, UniversalCompactionOptions)
	TEST (DBTest, ConvertCompactionStyle)
void	MinLevelHelper (DBTest *self, Options &options)
bool	MinLevelToCompress (CompressionType &type, Options &options, int wbits, int lev, int strategy)
	TEST (DBTest, MinLevelToCompress1)
	TEST (DBTest, MinLevelToCompress2)
	TEST (DBTest, RepeatedWritesToSameKey)
	TEST (DBTest, InPlaceUpdate)
	TEST (DBTest, CompactionFilter)
	TEST (DBTest, CompactionFilterWithValueChange)
	TEST (DBTest, SparseMerge)
static bool	Between (uint64_t val, uint64_t low, uint64_t high)
	TEST (DBTest, ApproximateSizes)
	TEST (DBTest, ApproximateSizes_MixOfSmallAndLarge)
	TEST (DBTest, IteratorPinsRef)
	TEST (DBTest, Snapshot)
	TEST (DBTest, HiddenValuesAreRemoved)
	TEST (DBTest, CompactBetweenSnapshots)
	TEST (DBTest, DeletionMarkers1)
	TEST (DBTest, DeletionMarkers2)
	TEST (DBTest, OverlapInLevel0)
	TEST (DBTest, L0_CompactionBug_Issue44_a)
	TEST (DBTest, L0_CompactionBug_Issue44_b)
	TEST (DBTest, ComparatorCheck)
	TEST (DBTest, CustomComparator)
	TEST (DBTest, ManualCompaction)
	TEST (DBTest, DBOpen_Options)
	TEST (DBTest, DBOpen_Change_NumLevels)
	TEST (DBTest, DestroyDBMetaDatabase)
	TEST (DBTest, NoSpace)
	TEST (DBTest, NonWritableFileSystem)
	TEST (DBTest, ManifestWriteError)
	TEST (DBTest, PutFailsParanoid)
	TEST (DBTest, FilesDeletedAfterCompaction)
	TEST (DBTest, BloomFilter)
	TEST (DBTest, SnapshotFiles)
	TEST (DBTest, CompactOnFlush)
std::vector< std::uint64_t >	ListLogFiles (Env *env, const std::string &path)
	TEST (DBTest, WALArchivalTtl)
uint64_t	GetLogDirSize (std::string dir_path, SpecialEnv *env)
	TEST (DBTest, WALArchivalSizeLimit)
SequenceNumber	ReadRecords (std::unique_ptr< TransactionLogIterator > &iter, int &count)
void	ExpectRecords (const int expected_no_records, std::unique_ptr< TransactionLogIterator > &iter)
	TEST (DBTest, TransactionLogIterator)
	TEST (DBTest, TransactionLogIteratorMoveOverZeroFiles)
	TEST (DBTest, TransactionLogIteratorJustEmptyFile)
	TEST (DBTest, TransactionLogIteratorCheckAfterRestart)
	TEST (DBTest, TransactionLogIteratorCorruptedLog)
	TEST (DBTest, TransactionLogIteratorBatchOperations)
	TEST (DBTest, TransactionLogIteratorBlobs)
	TEST (DBTest, ReadCompaction)
	TEST (DBTest, MultiThreaded)
static std::string	RandomKey (Random *rnd, int minimum=0)
static bool	CompareIterators (int step, DB *model, DB *db, const Snapshot *model_snap, const Snapshot *db_snap)
	TEST (DBTest, Randomized)
	TEST (DBTest, MultiGetSimple)
	TEST (DBTest, MultiGetEmpty)
void	PrefixScanInit (DBTest *dbtest)
	TEST (DBTest, PrefixScan)
std::string	MakeKey (unsigned int num)
void	BM_LogAndApply (int iters, int num_base_files)
static uint64_t	PackSequenceAndType (uint64_t seq, ValueType t)
void	AppendInternalKey (std::string *result, const ParsedInternalKey &key)
size_t	InternalKeyEncodingLength (const ParsedInternalKey &key)
bool	ParseInternalKey (const Slice &internal_key, ParsedInternalKey *result)
Slice	ExtractUserKey (const Slice &internal_key)
ValueType	ExtractValueType (const Slice &internal_key)
void	UpdateInternalKey (char *internal_key, const size_t internal_key_size, uint64_t seq, ValueType t)
uint64_t	GetInternalKeySeqno (const Slice &internal_key)
static std::string	IKey (const std::string &user_key, uint64_t seq, ValueType vt)
static std::string	Shorten (const std::string &s, const std::string &l)
static std::string	ShortSuccessor (const std::string &s)
static void	TestKey (const std::string &key, uint64_t seq, ValueType vt)
	TEST (FormatTest, InternalKey_EncodeDecode)
	TEST (FormatTest, InternalKeyShortSeparator)
	TEST (FormatTest, InternalKeyShortestSuccessor)
	TEST (DeleteFileTest, AddKeysAndQueryLevels)
	TEST (DeleteFileTest, PurgeObsoleteFilesTest)
	TEST (DeleteFileTest, DeleteFileWithIterator)
	TEST (DeleteFileTest, DeleteLogFiles)
static int	FlattenPath (const std::string &path, char *dest, int len)
Status	WriteStringToFileSync (Env *env, const Slice &data, const std::string &fname)
static std::string	MakeFileName (const std::string &name, uint64_t number, const char *suffix)
std::string	LogFileName (const std::string &name, uint64_t number)
std::string	ArchivalDirectory (const std::string &dir)
std::string	ArchivedLogFileName (const std::string &name, uint64_t number)
std::string	TableFileName (const std::string &name, uint64_t number)
std::string	DescriptorFileName (const std::string &dbname, uint64_t number)
std::string	CurrentFileName (const std::string &dbname)
std::string	LockFileName (const std::string &dbname)
std::string	TempFileName (const std::string &dbname, uint64_t number)
std::string	InfoLogFileName (const std::string &dbname, const std::string &db_path, const std::string &log_dir)
std::string	OldInfoLogFileName (const std::string &dbname, uint64_t ts, const std::string &db_path, const std::string &log_dir)
std::string	MetaDatabaseName (const std::string &dbname, uint64_t number)
std::string	IdentityFileName (const std::string &dbname)
bool	ParseFileName (const std::string &fname, uint64_t *number, FileType *type, WalFileType *log_type)
Status	SetCurrentFile (Env *env, const std::string &dbname, uint64_t descriptor_number)
Status	SetIdentityFile (Env *env, const std::string &dbname)
	TEST (FileNameTest, Parse)
	TEST (FileNameTest, Construction)
static const char *	EncodeKey (std::string *scratch, const Slice &target)
std::shared_ptr< DB >	OpenDb ()
	TEST (PerfContextTest, SeekIntoDeletion)
	TEST (PerfContextTest, StopWatchNanoOverhead)
	TEST (PerfContextTest, StopWatchOverhead)
void	ProfileKeyComparison ()
	TEST (PerfContextTest, KeyComparisonCount)
	TEST (PerfContextTest, SeekKeyComparison)
Slice	TestKeyToSlice (const TestKey &test_key)
const TestKey *	SliceToTestKey (const Slice &slice)
	TEST (PrefixTest, DynamicPrefixIterator)
	TEST (PrefixTest, PrefixHash)
Status	RepairDB (const std::string &dbname, const Options &options)
	TEST (SimpleTableDBTest, Empty)
	TEST (SimpleTableDBTest, ReadWrite)
	TEST (SimpleTableDBTest, Flush)
	TEST (SimpleTableDBTest, Flush2)
static std::string	Key (int i)
static std::string	RandomString (Random *rnd, int len)
	TEST (SimpleTableDBTest, CompactionTrigger)
	TEST (SkipTest, Empty)
	TEST (SkipTest, InsertAndLookup)
	TEST (SkipTest, ConcurrentWithoutThreads)
static void	ConcurrentReader (void *arg)
static void	RunConcurrent (int run)
	TEST (SkipTest, Concurrent1)
	TEST (SkipTest, Concurrent2)
	TEST (SkipTest, Concurrent3)
	TEST (SkipTest, Concurrent4)
	TEST (SkipTest, Concurrent5)
static void	DeleteEntry (const Slice &key, void *value)
static void	UnrefEntry (void *arg1, void *arg2)
uint64_t	GetDeletedKeys (const TableProperties::UserCollectedProperties &props)
void	MakeBuilder (const Options &options, std::unique_ptr< FakeWritableFile > *writable, std::unique_ptr< TableBuilder > *builder)
void	OpenTable (const Options &options, const std::string &contents, std::unique_ptr< TableReader > *table_reader)
	TEST (TablePropertiesTest, CustomizedTablePropertiesCollector)
	TEST (TablePropertiesTest, InternalKeyPropertiesCollector)
static bool	GetInternalKey (Slice *input, InternalKey *dst)
static void	TestEncodeDecode (const VersionEdit &edit)
	TEST (VersionEditTest, EncodeDecode)
static uint64_t	TotalFileSize (const std::vector< FileMetaData * > &files)
int	FindFile (const InternalKeyComparator &icmp, const std::vector< FileMetaData * > &files, const Slice &key)
static bool	AfterFile (const Comparator *ucmp, const Slice *user_key, const FileMetaData *f)
static bool	BeforeFile (const Comparator *ucmp, const Slice *user_key, const FileMetaData *f)
bool	SomeFileOverlapsRange (const InternalKeyComparator &icmp, bool disjoint_sorted_files, const std::vector< FileMetaData * > &files, const Slice *smallest_user_key, const Slice *largest_user_key)
static Iterator *	GetFileIterator (void *arg, const ReadOptions &options, const EnvOptions &soptions, const Slice &file_value, bool for_compaction)
static void	MarkKeyMayExist (void *arg)
static bool	SaveValue (void *arg, const Slice &ikey, const Slice &v, bool didIO)
static bool	NewestFirst (FileMetaData *a, FileMetaData *b)
static bool	NewestFirstBySeqNo (FileMetaData *a, FileMetaData *b)
static bool	compareSizeDescending (const VersionSet::Fsize &first, const VersionSet::Fsize &second)
static bool	compareSeqnoDescending (const VersionSet::Fsize &first, const VersionSet::Fsize &second)
static void	InputSummary (std::vector< FileMetaData * > &files, char *output, int len)
	TEST (FindFileTest, Empty)
	TEST (FindFileTest, Single)
	TEST (FindFileTest, Multiple)
	TEST (FindFileTest, MultipleNullBoundaries)
	TEST (FindFileTest, OverlapSequenceChecks)
	TEST (FindFileTest, OverlappingFiles)
static std::string	PrintContents (WriteBatch *b)
	TEST (WriteBatchTest, Empty)
	TEST (WriteBatchTest, Multiple)
	TEST (WriteBatchTest, Corruption)
	TEST (WriteBatchTest, Append)
	TEST (WriteBatchTest, Blob)
	TEST (WriteBatchTest, Continue)
	TEST (WriteBatchTest, PutGatherSlices)
Env *	NewMemEnv (Env *base_env)
	TEST (MemEnvTest, Basics)
	TEST (MemEnvTest, ReadWrite)
	TEST (MemEnvTest, Locks)
	TEST (MemEnvTest, Misc)
	TEST (MemEnvTest, LargeWrite)
	TEST (MemEnvTest, DBTest)
shared_ptr< Cache >	NewLRUCache (size_t capacity)
shared_ptr< Cache >	NewLRUCache (size_t capacity, int numShardBits)
shared_ptr< Cache >	NewLRUCache (size_t capacity, int numShardBits, int removeScanCountLimit)
const Comparator *	BytewiseComparator ()
void	LogFlush (const shared_ptr< Logger > &info_log)
void	Log (const shared_ptr< Logger > &info_log, const char *format,...)
void	LogFlush (Logger *info_log)
void	Log (Logger *info_log, const char *format,...)
Status	WriteStringToFile (Env *env, const Slice &data, const std::string &fname)
Status	ReadFileToString (Env *env, const std::string &fname, std::string *data)
const FilterPolicy *	NewBloomFilterPolicy (int bits_per_key)
Iterator *	NewEmptyIterator ()
Iterator *	NewErrorIterator (const Status &status)
MemTableRepFactory *	NewHashSkipListRepFactory (const SliceTransform *transform, size_t bucket_count=1000000)
void	SetPerfLevel (PerfLevel level)
bool	operator== (const Slice &x, const Slice &y)
bool	operator!= (const Slice &x, const Slice &y)
const SliceTransform *	NewFixedPrefixTransform (size_t prefix_len)
const SliceTransform *	NewNoopTransform ()
void	RecordTick (std::shared_ptr< Statistics > statistics, Tickers ticker, uint64_t count=1)
void	SetTickerCount (std::shared_ptr< Statistics > statistics, Tickers ticker, uint64_t count)
void	InstallStackTraceHandler ()
static const char *	DecodeEntry (const char *p, const char *limit, uint32_t *shared, uint32_t *non_shared, uint32_t *value_length)
static void	DeleteCachedBlock (const Slice &key, void *value)
bool	SaveDidIO (void *arg, const Slice &key, const Slice &value, bool didIO)
static std::string	RandomString (Random *rnd, int len)
	TEST (BlockTest, SimpleTest)
	TEST (FilterBlockTest, EmptyBuilder)
	TEST (FilterBlockTest, SingleChunk)
	TEST (FilterBlockTest, MultiChunk)
Status	ReadBlockContents (RandomAccessFile *file, const ReadOptions &options, const BlockHandle &handle, BlockContents *result, Env *env, bool do_uncompress)
Status	UncompressBlockContents (const char *data, size_t n, BlockContents *result)
MaxIterHeap	NewMaxIterHeap (const Comparator *comparator)
MinIterHeap	NewMinIterHeap (const Comparator *comparator)
Iterator *	NewMergingIterator (const Comparator *cmp, Iterator **list, int n)
static std::string	MakeKey (int i, int j, bool through_db)
static bool	DummySaveValue (void *arg, const Slice &ikey, const Slice &v, bool didIO)
void	TableReaderBenchmark (Options &opts, EnvOptions &env_options, ReadOptions &read_options, int num_keys1, int num_keys2, int num_iter, int prefix_len, bool if_query_empty_keys, bool for_iterator, bool through_db)
static void	Increment (const Comparator *cmp, std::string *key)
static bool	SnappyCompressionSupported ()
static bool	ZlibCompressionSupported ()
static std::vector< TestArgs >	GenerateArgList ()
	TEST (Harness, SimpleEmptyKey)
	TEST (Harness, SimpleSingle)
	TEST (Harness, SimpleMulti)
	TEST (Harness, SimpleSpecialKey)
static bool	Between (uint64_t val, uint64_t low, uint64_t high)
	TEST (TableTest, BasicTableProperties)
	TEST (TableTest, FilterPolicyNameProperties)
static std::string	RandomString (Random *rnd, int len)
	TEST (TableTest, IndexSizeStat)
	TEST (TableTest, NumBlockStat)
	TEST (TableTest, BlockCacheTest)
	TEST (TableTest, ApproximateOffsetOfPlain)
static void	Do_Compression_Test (CompressionType comp)
	TEST (TableTest, ApproximateOffsetOfCompressed)
	TEST (TableTest, BlockCacheLeak)
	TEST (Harness, Randomized)
	TEST (Harness, RandomizedLongDB)
	TEST (MemTableTest, Simple)
Iterator *	NewTwoLevelIterator (Iterator *index_iter, BlockFunction block_function, void *arg, const ReadOptions &options, const EnvOptions &soptions, bool for_compaction)
Iterator *	NewTwoLevelIterator (Iterator *index_iter, Iterator *(*block_function)(void *arg, const ReadOptions &options, const EnvOptions &soptions, const Slice &index_value, bool for_compaction), void *arg, const ReadOptions &options, const EnvOptions &soptions, bool for_compaction=false)
static std::string	Key (long val)
	TEST (ReduceLevelTest, Last_Level)
	TEST (ReduceLevelTest, Top_Level)
	TEST (ReduceLevelTest, All_Levels)
	TEST (ArenaImplTest, Empty)
	TEST (ArenaImplTest, MemoryAllocatedBytes)
	TEST (ArenaImplTest, Simple)
Status	CreateLoggerFromOptions (const std::string &dbname, const std::string &db_log_dir, Env *env, const Options &options, std::shared_ptr< Logger > *logger)
void	LogMessage (Logger *logger, const char *message)
void	GetFileCreateTime (const std::string &fname, uint64_t *file_ctime)
	TEST (AutoRollLoggerTest, RollLogFileBySize)
	TEST (AutoRollLoggerTest, RollLogFileByTime)
	TEST (AutoRollLoggerTest, OpenLogFilesMultipleTimesWithOptionLog_max_size)
	TEST (AutoRollLoggerTest, CompositeRollByTimeAndSizeLogger)
	TEST (AutoRollLoggerTest, CreateLoggerFromOptions)
int	OldLogFileCount (const string &dir)
	TEST (BlobStoreTest, RangeParseTest)
	TEST (BlobStoreTest, SanityTest)
	TEST (BlobStoreTest, FragmentedChunksTest)
	TEST (BlobStoreTest, CreateAndStoreTest)
	TEST (BlobStoreTest, MaxSizeTest)
static Slice	Key (int i, char *buffer)
	TEST (BloomTest, EmptyFilter)
	TEST (BloomTest, Small)
static int	NextLength (int length)
	TEST (BloomTest, VaryingLengths)
static std::string	EncodeKey (int k)
static int	DecodeKey (const Slice &k)
static void *	EncodeValue (uintptr_t v)
static int	DecodeValue (void *v)
	TEST (CacheTest, HitAndMiss)
	TEST (CacheTest, Erase)
	TEST (CacheTest, EntriesArePinned)
	TEST (CacheTest, EvictionPolicy)
	TEST (CacheTest, EvictionPolicyRef)
	TEST (CacheTest, EvictionPolicyRef2)
	TEST (CacheTest, EvictionPolicyRefLargeScanLimit)
	TEST (CacheTest, HeavyEntries)
	TEST (CacheTest, NewId)
void	deleter (const Slice &key, void *value)
	TEST (CacheTest, BadEviction)
void	EncodeFixed32 (char *buf, uint32_t value)
void	EncodeFixed64 (char *buf, uint64_t value)
void	PutFixed32 (std::string *dst, uint32_t value)
void	PutFixed64 (std::string *dst, uint64_t value)
char *	EncodeVarint32 (char *dst, uint32_t v)
void	PutVarint32 (std::string *dst, uint32_t v)
char *	EncodeVarint64 (char *dst, uint64_t v)
void	PutVarint64 (std::string *dst, uint64_t v)
void	PutLengthPrefixedSlice (std::string *dst, const Slice &value)
void	PutLengthPrefixedSliceParts (std::string *dst, const SliceParts &slice_parts)
int	VarintLength (uint64_t v)
const char *	GetVarint32PtrFallback (const char *p, const char *limit, uint32_t *value)
bool	GetVarint32 (Slice *input, uint32_t *value)
const char *	GetVarint64Ptr (const char *p, const char *limit, uint64_t *value)
bool	GetVarint64 (Slice *input, uint64_t *value)
const char *	GetLengthPrefixedSlice (const char *p, const char *limit, Slice *result)
bool	GetLengthPrefixedSlice (Slice *input, Slice *result)
Slice	GetLengthPrefixedSlice (const char *data)
void	BitStreamPutInt (char *dst, size_t dstlen, size_t offset, uint32_t bits, uint64_t value)
uint64_t	BitStreamGetInt (const char *src, size_t srclen, size_t offset, uint32_t bits)
void	BitStreamPutInt (std::string *dst, size_t offset, uint32_t bits, uint64_t value)
uint64_t	BitStreamGetInt (const std::string *src, size_t offset, uint32_t bits)
uint64_t	BitStreamGetInt (const Slice *src, size_t offset, uint32_t bits)
const char *	GetVarint32Ptr (const char *p, const char *limit, uint32_t *v)
uint32_t	DecodeFixed32 (const char *ptr)
uint64_t	DecodeFixed64 (const char *ptr)
	TEST (Coding, Fixed32)
	TEST (Coding, Fixed64)
	TEST (Coding, EncodingOutput)
	TEST (Coding, Varint32)
	TEST (Coding, Varint64)
	TEST (Coding, Varint32Overflow)
	TEST (Coding, Varint32Truncation)
	TEST (Coding, Varint64Overflow)
	TEST (Coding, Varint64Truncation)
	TEST (Coding, Strings)
	TEST (Coding, BitStream)
	TEST (Coding, BitStreamConvenienceFuncs)
static void	InitModule ()
static Status	DoWriteStringToFile (Env *env, const Slice &data, const std::string &fname, bool should_sync)
static void	SetBool (void *ptr)
	TEST (EnvPosixTest, RunImmediately)
	TEST (EnvPosixTest, RunMany)
static void	ThreadBody (void *arg)
	TEST (EnvPosixTest, StartThread)
	TEST (EnvPosixTest, TwoPools)
bool	IsSingleVarint (const std::string &s)
	TEST (EnvPosixTest, PosixRandomRWFileTest)
	TEST (LockTest, LockBySameThread)
uint32_t	Hash (const char *data, size_t n, uint32_t seed)
	maxBucketValue_ (bucketValues_.back())
	minBucketValue_ (bucketValues_.front())
	TEST (HistogramTest, BasicOperation)
	TEST (HistogramTest, EmptyHistogram)
	TEST (HistogramTest, ClearHistogram)
	null_from_ (true)
	null_to_ (true)
	create_if_missing_ (false)
	disable_wal_ (false)
	bulk_load_ (false)
	compact_ (false)
	verbose_ (false)
	path_ ("")
string	ReadableTime (int unixtime)
void	IncBucketCounts (vector< uint64_t > &bucket_counts, int ttl_start, int time_range, int bucket_size, int timekv, int num_buckets)
void	PrintBucketCounts (const vector< uint64_t > &bucket_counts, int ttl_start, int ttl_end, int bucket_size, int num_buckets)
	has_from_ (false)
	has_to_ (false)
	max_keys_ (-1)
	delim_ (".")
	count_only_ (false)
	count_delim_ (false)
	print_stats_ (false)
	is_input_key_hex_ (false)
	old_levels_ (1<< 16)
	new_levels_ (-1)
	print_old_levels_ (false)
	old_compaction_style_ (-1)
	new_compaction_style_ (-1)
	print_header_ (false)
	print_values_ (false)
	if (params.size()!=1)
	if (is_key_hex_)
	start_key_specified_ (false)
	end_key_specified_ (false)
	max_keys_scanned_ (-1)
void	AppendNumberTo (std::string *str, uint64_t num)
void	AppendEscapedStringTo (std::string *str, const Slice &value)
std::string	NumberToString (uint64_t num)
std::string	EscapeString (const Slice &value)
bool	ConsumeChar (Slice *in, char c)
bool	ConsumeDecimalNumber (Slice *in, uint64_t *val)
void	StartPerfTimer (StopWatchNano *timer)
void	BumpPerfCount (uint64_t *count, uint64_t delta=1)
void	BumpPerfTime (uint64_t *time, StopWatchNano *timer, bool reset=true)
vector< string >	stringSplit (string arg, char delim)
std::shared_ptr< DB >	OpenNormalDb (char delim_char)
std::shared_ptr< DB >	OpenTtlDb (char delim_char)
	TEST (StringAppendOperatorTest, IteratorTest)
	TEST (StringAppendOperatorTest, SimpleTest)
	TEST (StringAppendOperatorTest, SimpleDelimiterTest)
	TEST (StringAppendOperatorTest, OneValueNoDelimiterTest)
	TEST (StringAppendOperatorTest, VariousKeys)
	TEST (StringAppendOperatorTest, RandomMixGetAppend)
	TEST (StringAppendOperatorTest, BIGRandomMixGetAppend)
	TEST (StringAppendOperatorTest, PersistentVariousKeys)
	TEST (StringAppendOperatorTest, PersistentFlushAndCompaction)
	TEST (StringAppendOperatorTest, SimpleTestNullDelimiter)
void	AssertListEq (const std::vector< std::string > &result, const std::vector< std::string > &expected_result)
	TEST (RedisListsTest, SimpleTest)
	TEST (RedisListsTest, SimpleTest2)
	TEST (RedisListsTest, IndexTest)
	TEST (RedisListsTest, RangeTest)
	TEST (RedisListsTest, InsertTest)
	TEST (RedisListsTest, SetTest)
	TEST (RedisListsTest, InsertPushSetTest)
	TEST (RedisListsTest, TrimPopTest)
	TEST (RedisListsTest, RemoveTest)
	TEST (RedisListsTest, PersistenceMultiKeyTest)
void	MakeUpper (std::string *const s)
int	manual_redis_test (bool destructive)
	TEST (TtlTest, NoEffect)
	TEST (TtlTest, PresentDuringTTL)
	TEST (TtlTest, AbsentAfterTTL)
	TEST (TtlTest, ResetTimestamp)
	TEST (TtlTest, IterPresentDuringTTL)
	TEST (TtlTest, IterAbsentAfterTTL)
	TEST (TtlTest, MultiOpenSamePresent)
	TEST (TtlTest, MultiOpenSameAbsent)
	TEST (TtlTest, MultiOpenDifferent)
	TEST (TtlTest, ReadOnlyPresentForever)
	TEST (TtlTest, WriteBatchTest)
	TEST (TtlTest, CompactionFilter)
	TEST (TtlTest, KeyMayExist)

Variables
static const int	kValueSize = 1000
static int	cfilter_count
static std::string	NEW_VALUE = "NewValue"
static const ValueType	kValueTypeForSeek = kTypeMerge
static const SequenceNumber	kMaxSequenceNumber
static const std::string	ARCHIVAL_DIR = "archive"
static const size_t	kHeader = 12
static const Status	notsup
static const int	kMajorVersion = 2
static const int	kMinorVersion = 0
__thread PerfContext	perf_context
const std::vector< std::pair < Tickers, std::string > >	TickersNameMap
const std::vector< std::pair < Histograms, std::string > >	HistogramsNameMap
const size_t	kMaxCacheKeyPrefixSize = kMaxVarint64Length*3+1
static const size_t	kFilterBaseLg = 11
static const size_t	kFilterBase = 1 << kFilterBaseLg
static const uint64_t	kTableMagicNumber = 0xdb4775248b80fb57ull
static const size_t	kBlockTrailerSize = 5
static ReverseKeyComparator	reverse_key_comparator
static const int	kVerbose = 1
const unsigned int	kMaxVarint32Length = 5
const unsigned int	kMaxVarint64Length = 10
static port::OnceType	once = LEVELDB_ONCE_INIT
static const Comparator *	bytewise
static const int	kDelayMicros = 100000
	else
static const char *const	access_hints []
PerfLevel	perf_level = kEnableCount
const int	kDebugLogChunkSize = 128 * 1024
const std::string	kDbName = "/tmp/mergetestdb"

Detailed Description

Back-end implementation details specific to the Merge Operator.

A MergeOperator for rocksdb that implements string append.

Author

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

A TEST MergeOperator for rocksdb that implements string append. It is built using the MergeOperator interface rather than the simpler AssociativeMergeOperator interface. This is useful for testing/benchmarking. While the two operators are semantically the same, all production code should use the StringAppendOperator defined in stringappend.{h,cc}. The operator defined in the present file is primarily for testing.

Author

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

A simple structure for exceptions in RedisLists.

Author

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

RedisListIterator: An abstraction over the "list" concept (e.g.: for redis lists). Provides functionality to read, traverse, edit, and write these lists.

Upon construction, the RedisListIterator is given a block of list data. Internally, it stores a pointer to the data and a pointer to current item. It also stores a "result" list that will be mutated over time.

Traversal and mutation are done by "forward iteration". The Push() and Skip() methods will advance the iterator to the next item. However, Push() will also "write the current item to the result". Skip() will simply move to next item, causing current item to be dropped.

Upon completion, the result (accessible by WriteResult()) will be saved. All "skipped" items will be gone; all "pushed" items will remain.

Exceptions

Any	of the operations may throw a RedisListException if an invalid operation is performed or if the data is found to be corrupt.

By default, if WriteResult() is called part-way through iteration, it will automatically advance the iterator to the end, and Keep() all items that haven't been traversed yet. This may be subject to review.

Can access the "current" item via GetCurrent(), and other list-specific information such as Length().

The internal representation is due to change at any time. Presently, the list is represented as follows:

• 32-bit integer header: the number of items in the list
• For each item:
  • 32-bit int (n): the number of bytes representing this item
  • n bytes of data: the actual data.

Author

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

A (persistent) Redis API built using the rocksdb backend. Implements Redis Lists as described on: http://redis.io/commands#list

Exceptions

All	functions may throw a RedisListException on error/corruption.

Internally, the set of lists is stored in a rocksdb database, mapping keys to values. Each "value" is the list itself, storing some kind of internal representation of the data. All the representation details are handled by the RedisListIterator class. The present file should be oblivious to the representation details, handling only the client (Redis) API, and the calls to rocksdb.

Presently, all operations take at least O(NV) time where N is the number of elements in the list, and V is the average number of bytes per value in the list. So maybe, with merge operator we can improve this to an optimal O(V) amortized time, since we wouldn't have to read and re-write the entire list.

Author

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

A (persistent) Redis API built using the rocksdb backend. Implements Redis Lists as described on: http://redis.io/commands#list

Exceptions

All	functions may throw a RedisListException

Author

Deon Nicholas (dnich.nosp@m.olas.nosp@m.@fb.c.nosp@m.om) Copyright 2013 Facebook

Typedef Documentation

typedef uint64_t rocksdb::Key

Definition at line 20 of file skiplist_test.cc.

typedef std::map<std::string, std::string, anon::STLLessThan> rocksdb::KVMap

Definition at line 159 of file table_test.cc.

typedef std::priority_queue< IteratorWrapper*, std::vector<IteratorWrapper*>, MaxIteratorComparator> rocksdb::MaxIterHeap

Definition at line 47 of file iter_heap.h.

typedef std::priority_queue< IteratorWrapper*, std::vector<IteratorWrapper*>, MinIteratorComparator> rocksdb::MinIterHeap

Definition at line 52 of file iter_heap.h.

typedef uint64_t rocksdb::SequenceNumber

Definition at line 16 of file types.h.

typedef std::vector<std::unique_ptr<LogFile> > rocksdb::VectorLogPtr

Definition at line 17 of file transaction_log.h.

Enumeration Type Documentation

enum rocksdb::CompactionStopStyle

Enumerator
kCompactionStopStyleSimilarSize
kCompactionStopStyleTotalSize

Definition at line 24 of file universal_compaction.h.

                         {
  kCompactionStopStyleSimilarSize, // pick files of similar size
  kCompactionStopStyleTotalSize    // total size of picked files > next file
};

enum rocksdb::CompactionStyle : char

Enumerator
kCompactionStyleLevel
kCompactionStyleUniversal

Definition at line 55 of file options.h.

                     : char {
  kCompactionStyleLevel       = 0x0, // level based compaction style
  kCompactionStyleUniversal   = 0x1  // Universal compaction style
};

enum rocksdb::CompressionType : char

Enumerator
kNoCompression
kSnappyCompression
kZlibCompression
kBZip2Compression

Definition at line 46 of file options.h.

                     : char {
  // NOTE: do not change the values of existing entries, as these are
  // part of the persistent format on disk.
  kNoCompression     = 0x0,
  kSnappyCompression = 0x1,
  kZlibCompression = 0x2,
  kBZip2Compression = 0x3
};

enum rocksdb::FileType

Enumerator
kLogFile
kDBLockFile
kTableFile
kDescriptorFile
kCurrentFile
kTempFile
kInfoLogFile
kMetaDatabase
kIdentityFile

Definition at line 24 of file filename.h.

              {
  kLogFile,
  kDBLockFile,
  kTableFile,
  kDescriptorFile,
  kCurrentFile,
  kTempFile,
  kInfoLogFile,  // Either the current one, or an old one
  kMetaDatabase,
  kIdentityFile
};

enum rocksdb::Histograms

Keep adding histogram's here. Any histogram whould have value less than HISTOGRAM_ENUM_MAX Add a new Histogram by assigning it the current value of HISTOGRAM_ENUM_MAX Add a string representation in HistogramsNameMap below And increment HISTOGRAM_ENUM_MAX

Enumerator
DB_GET
DB_WRITE
COMPACTION_TIME
TABLE_SYNC_MICROS
COMPACTION_OUTFILE_SYNC_MICROS
WAL_FILE_SYNC_MICROS
MANIFEST_FILE_SYNC_MICROS
TABLE_OPEN_IO_MICROS
DB_MULTIGET
READ_BLOCK_COMPACTION_MICROS
READ_BLOCK_GET_MICROS
WRITE_RAW_BLOCK_MICROS
STALL_L0_SLOWDOWN_COUNT
STALL_MEMTABLE_COMPACTION_COUNT
STALL_L0_NUM_FILES_COUNT
HARD_RATE_LIMIT_DELAY_COUNT
SOFT_RATE_LIMIT_DELAY_COUNT
NUM_FILES_IN_SINGLE_COMPACTION
HISTOGRAM_ENUM_MAX

Definition at line 165 of file statistics.h.

                {
  DB_GET,
  DB_WRITE,
  COMPACTION_TIME,
  TABLE_SYNC_MICROS,
  COMPACTION_OUTFILE_SYNC_MICROS,
  WAL_FILE_SYNC_MICROS,
  MANIFEST_FILE_SYNC_MICROS,
  // TIME SPENT IN IO DURING TABLE OPEN
  TABLE_OPEN_IO_MICROS,
  DB_MULTIGET,
  READ_BLOCK_COMPACTION_MICROS,
  READ_BLOCK_GET_MICROS,
  WRITE_RAW_BLOCK_MICROS,

  STALL_L0_SLOWDOWN_COUNT,
  STALL_MEMTABLE_COMPACTION_COUNT,
  STALL_L0_NUM_FILES_COUNT,
  HARD_RATE_LIMIT_DELAY_COUNT,
  SOFT_RATE_LIMIT_DELAY_COUNT,
  NUM_FILES_IN_SINGLE_COMPACTION,
  HISTOGRAM_ENUM_MAX,
};

enum rocksdb::PerfLevel

Enumerator
kDisable
kEnableCount
kEnableTime

Definition at line 13 of file perf_context.h.

               {
  kDisable        = 0,  // disable perf stats
  kEnableCount    = 1,  // enable only count stats
  kEnableTime     = 2   // enable time stats too
};

enum rocksdb::ReadTier

Enumerator
kReadAllTier
kBlockCacheTier

Definition at line 636 of file options.h.

              {
  kReadAllTier    = 0x0, // data in memtable, block cache, OS cache or storage
  kBlockCacheTier = 0x1  // data in memtable or block cache
};

enum rocksdb::Tag

Enumerator
kComparator
kLogNumber
kNextFileNumber
kLastSequence
kCompactPointer
kDeletedFile
kNewFile
kPrevLogNumber
kNewFile2

Definition at line 19 of file version_edit.cc.

         {
  kComparator           = 1,
  kLogNumber            = 2,
  kNextFileNumber       = 3,
  kLastSequence         = 4,
  kCompactPointer       = 5,
  kDeletedFile          = 6,
  kNewFile              = 7,
  // 8 was used for large value refs
  kPrevLogNumber        = 9,

  // these are new formats divergent from open source leveldb
  kNewFile2             = 100  // store smallest & largest seqno
};

enum rocksdb::TestType

Enumerator
TABLE_TEST
BLOCK_TEST
MEMTABLE_TEST
DB_TEST

Definition at line 478 of file table_test.cc.

              {
  TABLE_TEST,
  BLOCK_TEST,
  MEMTABLE_TEST,
  DB_TEST
};

enum rocksdb::Tickers

Keep adding ticker's here. Any ticker should have a value less than TICKER_ENUM_MAX. Add a new ticker by assigning it the current value of TICKER_ENUM_MAX Add a string representation in TickersNameMap below. And incrementing TICKER_ENUM_MAX.

Enumerator
BLOCK_CACHE_MISS
BLOCK_CACHE_HIT
BLOCK_CACHE_ADD
BLOCK_CACHE_INDEX_MISS
BLOCK_CACHE_INDEX_HIT
BLOCK_CACHE_FILTER_MISS
BLOCK_CACHE_FILTER_HIT
BLOCK_CACHE_DATA_MISS
BLOCK_CACHE_DATA_HIT
BLOOM_FILTER_USEFUL
COMPACTION_KEY_DROP_NEWER_ENTRY	COMPACTION_KEY_DROP_* count the reasons for key drop during compaction There are 3 reasons currently.
COMPACTION_KEY_DROP_OBSOLETE
COMPACTION_KEY_DROP_USER
NUMBER_KEYS_WRITTEN
NUMBER_KEYS_READ
NUMBER_KEYS_UPDATED
BYTES_WRITTEN
BYTES_READ
NO_FILE_CLOSES
NO_FILE_OPENS
NO_FILE_ERRORS
STALL_L0_SLOWDOWN_MICROS
STALL_MEMTABLE_COMPACTION_MICROS
STALL_L0_NUM_FILES_MICROS
RATE_LIMIT_DELAY_MILLIS
NO_ITERATORS
NUMBER_MULTIGET_CALLS
NUMBER_MULTIGET_KEYS_READ
NUMBER_MULTIGET_BYTES_READ
NUMBER_FILTERED_DELETES
NUMBER_MERGE_FAILURES
SEQUENCE_NUMBER
BLOOM_FILTER_PREFIX_CHECKED
BLOOM_FILTER_PREFIX_USEFUL
NUMBER_OF_RESEEKS_IN_ITERATION
GET_UPDATES_SINCE_CALLS
BLOCK_CACHE_COMPRESSED_MISS
BLOCK_CACHE_COMPRESSED_HIT
TICKER_ENUM_MAX

Definition at line 26 of file statistics.h.

             {
  // total block cache misses
  // REQUIRES: BLOCK_CACHE_MISS == BLOCK_CACHE_INDEX_MISS +
  //                               BLOCK_CACHE_FILTER_MISS +
  //                               BLOCK_CACHE_DATA_MISS;
  BLOCK_CACHE_MISS,
  // total block cache hit
  // REQUIRES: BLOCK_CACHE_HIT == BLOCK_CACHE_INDEX_HIT +
  //                              BLOCK_CACHE_FILTER_HIT +
  //                              BLOCK_CACHE_DATA_HIT;
  BLOCK_CACHE_HIT,
  // # of blocks added to block cache.
  BLOCK_CACHE_ADD,
  // # of times cache miss when accessing index block from block cache.
  BLOCK_CACHE_INDEX_MISS,
  // # of times cache hit when accessing index block from block cache.
  BLOCK_CACHE_INDEX_HIT,
  // # of times cache miss when accessing filter block from block cache.
  BLOCK_CACHE_FILTER_MISS,
  // # of times cache hit when accessing filter block from block cache.
  BLOCK_CACHE_FILTER_HIT,
  // # of times cache miss when accessing data block from block cache.
  BLOCK_CACHE_DATA_MISS,
  // # of times cache hit when accessing data block from block cache.
  BLOCK_CACHE_DATA_HIT,
  // # of times bloom filter has avoided file reads.
  BLOOM_FILTER_USEFUL,

  COMPACTION_KEY_DROP_NEWER_ENTRY, // key was written with a newer value.
  COMPACTION_KEY_DROP_OBSOLETE, // The key is obsolete.
  COMPACTION_KEY_DROP_USER, // user compaction function has dropped the key.

  // Number of keys written to the database via the Put and Write call's
  NUMBER_KEYS_WRITTEN,
  // Number of Keys read,
  NUMBER_KEYS_READ,
  // Number keys updated, if inplace update is enabled
  NUMBER_KEYS_UPDATED,
  // Bytes written / read
  BYTES_WRITTEN,
  BYTES_READ,
  NO_FILE_CLOSES,
  NO_FILE_OPENS,
  NO_FILE_ERRORS,
  // Time system had to wait to do LO-L1 compactions
  STALL_L0_SLOWDOWN_MICROS,
  // Time system had to wait to move memtable to L1.
  STALL_MEMTABLE_COMPACTION_MICROS,
  // write throttle because of too many files in L0
  STALL_L0_NUM_FILES_MICROS,
  RATE_LIMIT_DELAY_MILLIS,

  NO_ITERATORS, // number of iterators currently open

  // Number of MultiGet calls, keys read, and bytes read
  NUMBER_MULTIGET_CALLS,
  NUMBER_MULTIGET_KEYS_READ,
  NUMBER_MULTIGET_BYTES_READ,

  // Number of deletes records that were not required to be
  // written to storage because key does not exist
  NUMBER_FILTERED_DELETES,
  NUMBER_MERGE_FAILURES,
  SEQUENCE_NUMBER,

  // number of times bloom was checked before creating iterator on a
  // file, and the number of times the check was useful in avoiding
  // iterator creation (and thus likely IOPs).
  BLOOM_FILTER_PREFIX_CHECKED,
  BLOOM_FILTER_PREFIX_USEFUL,

  // Number of times we had to reseek inside an iteration to skip
  // over large number of keys with same userkey.
  NUMBER_OF_RESEEKS_IN_ITERATION,

  // Record the number of calls to GetUpadtesSince. Useful to keep track of
  // transaction log iterator refreshes
  GET_UPDATES_SINCE_CALLS,

  BLOCK_CACHE_COMPRESSED_MISS, // miss in the compressed block cache
  BLOCK_CACHE_COMPRESSED_HIT,  // hit in the compressed block cache

  TICKER_ENUM_MAX
};

enum rocksdb::ValueType

Enumerator
kTypeDeletion
kTypeValue
kTypeMerge
kTypeLogData

Definition at line 28 of file dbformat.h.

               {
  kTypeDeletion = 0x0,
  kTypeValue = 0x1,
  kTypeMerge = 0x2,
  kTypeLogData = 0x3
};

enum rocksdb::WalFileType

Enumerator
kArchivedLogFile
kAliveLogFile

Definition at line 20 of file transaction_log.h.

                  {
  /* Indicates that WAL file is in archive directory. WAL files are moved from
   * the main db directory to archive directory once they are not live and stay
   * there until cleaned up. Files are cleaned depending on archive size
   * (Options::WAL_size_limit_MB) and time since last cleaning
   * (Options::WAL_ttl_seconds).
   */
  kArchivedLogFile = 0,

  /* Indicates that WAL file is live and resides in the main db directory */
  kAliveLogFile = 1
} ;

Function Documentation

static bool rocksdb::AfterFile ( const Comparator *  ucmp, const Slice *  user_key, const FileMetaData *  f  )

static

Definition at line 81 of file version_set.cc.

References rocksdb::Comparator::Compare(), rocksdb::FileMetaData::largest, and rocksdb::InternalKey::user_key().

Referenced by SomeFileOverlapsRange().

                                                                    {
  // nullptr user_key occurs before all keys and is therefore never after *f
  return (user_key != nullptr &&
          ucmp->Compare(*user_key, f->largest.user_key()) > 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::AppendEscapedStringTo	(	std::string *	str,
		const Slice &	value
	)

Definition at line 27 of file logging.cc.

References rocksdb::Slice::size().

Referenced by EscapeString().

                                                               {
  for (size_t i = 0; i < value.size(); i++) {
    char c = value[i];
    if (c >= ' ' && c <= '~') {
      str->push_back(c);
    } else {
      char buf[10];
      snprintf(buf, sizeof(buf), "\\x%02x",
               static_cast<unsigned int>(c) & 0xff);
      str->append(buf);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::AppendInternalKey	(	std::string *	result,
		const ParsedInternalKey &	key
	)

Definition at line 24 of file dbformat.cc.

References rocksdb::Slice::data(), PackSequenceAndType(), PutFixed64(), rocksdb::ParsedInternalKey::sequence, rocksdb::Slice::size(), rocksdb::ParsedInternalKey::type, and rocksdb::ParsedInternalKey::user_key.

Referenced by IKey(), rocksdb::InternalKey::InternalKey(), rocksdb::KeyConvertingIterator::Seek(), and rocksdb::InternalKey::SetFrom().

                                                                        {
  result->append(key.user_key.data(), key.user_key.size());
  PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::AppendNumberTo	(	std::string *	str,
		uint64_t	num
	)

Definition at line 21 of file logging.cc.

Referenced by rocksdb::VersionEdit::DebugString(), rocksdb::Version::DebugString(), rocksdb::TtlTest::MakeKVMap(), and NumberToString().

                                                  {
  char buf[30];
  snprintf(buf, sizeof(buf), "%llu", (unsigned long long) num);
  str->append(buf);
}

Here is the caller graph for this function:

static void rocksdb::AppendWithSpace ( std::string *  str, Slice  msg  )

static

Definition at line 528 of file db_bench.cc.

References rocksdb::Slice::data(), rocksdb::Slice::empty(), and rocksdb::Slice::size().

Referenced by rocksdb::Stats::AddMessage(), and rocksdb::Stats::Report().

                                                       {
  if (msg.empty()) return;
  if (!str->empty()) {
    str->push_back(' ');
  }
  str->append(msg.data(), msg.size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::ArchivalDirectory

(

const std::string &

dir)

Definition at line 65 of file filename.cc.

References ARCHIVAL_DIR.

Referenced by rocksdb::DBImpl::CreateArchivalDirectory(), DestroyDB(), rocksdb::DBImpl::GetSortedWalFiles(), rocksdb::DBImpl::PurgeObsoleteWALFiles(), and TEST().

                                                  {
  return dir + "/" + ARCHIVAL_DIR;
}

Here is the caller graph for this function:

std::string rocksdb::ArchivedLogFileName	(	const std::string &	name,
		uint64_t	number
	)

Definition at line 68 of file filename.cc.

References ARCHIVAL_DIR, and MakeFileName().

Referenced by rocksdb::DBImpl::CheckWalFileExistsAndEmpty(), rocksdb::TransactionLogIteratorImpl::OpenLogFile(), rocksdb::LogFileImpl::PathName(), rocksdb::DBImpl::PurgeObsoleteFiles(), and rocksdb::DBImpl::ReadFirstRecord().

                                                                      {
  assert(number > 0);
  return MakeFileName(name + "/" + ARCHIVAL_DIR, number, "log");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::AssertListEq	(	const std::vector< std::string > &	result,
		const std::vector< std::string > &	expected_result
	)

Definition at line 44 of file redis_lists_test.cc.

References ASSERT_EQ.

Referenced by TEST().

                                                               {
  ASSERT_EQ(result.size(), expected_result.size());
  for (size_t i = 0; i < result.size(); ++i) {
    ASSERT_EQ(result[i], expected_result[i]);
  }
}

Here is the caller graph for this function:

static bool rocksdb::BeforeFile ( const Comparator *  ucmp, const Slice *  user_key, const FileMetaData *  f  )

static

Definition at line 88 of file version_set.cc.

References rocksdb::Comparator::Compare(), rocksdb::FileMetaData::smallest, and rocksdb::InternalKey::user_key().

Referenced by SomeFileOverlapsRange().

                                                                     {
  // nullptr user_key occurs after all keys and is therefore never before *f
  return (user_key != nullptr &&
          ucmp->Compare(*user_key, f->smallest.user_key()) < 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::Between ( uint64_t  val, uint64_t  low, uint64_t  high  )

static

Definition at line 789 of file table_test.cc.

                                                               {
  bool result = (val >= low) && (val <= high);
  if (!result) {
    fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
            (unsigned long long)(val),
            (unsigned long long)(low),
            (unsigned long long)(high));
  }
  return result;
}

static bool rocksdb::Between ( uint64_t  val, uint64_t  low, uint64_t  high  )

static

Definition at line 2861 of file db_test.cc.

Referenced by Do_Compression_Test(), and TEST().

                                                               {
  bool result = (val >= low) && (val <= high);
  if (!result) {
    fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
            (unsigned long long)(val),
            (unsigned long long)(low),
            (unsigned long long)(high));
  }
  return result;
}

Here is the caller graph for this function:

uint64_t rocksdb::BitStreamGetInt	(	const char *	src,
		size_t	srclen,
		size_t	offset,
		uint32_t	bits
	)

Definition at line 253 of file coding.cc.

Referenced by BitStreamGetInt(), BitStreamPutInt(), and TEST().

                                        {
  assert((offset + bits + 7)/8 <= srclen);
  assert(bits <= 64);

  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(src);

  uint64_t result = 0;

  size_t byteOffset = offset / 8;
  size_t bitOffset = offset % 8;
  size_t shift = 0;

  while (bits > 0) {
    size_t bitsToGet = std::min<size_t>(bits, 8 - bitOffset);
    unsigned char mask = ((1 << bitsToGet) - 1);

    result += (uint64_t)((ptr[byteOffset] >> bitOffset) & mask) << shift;

    shift += bitsToGet;
    byteOffset += 1;
    bitOffset = 0;
    bits -= bitsToGet;
  }

  return result;
}

Here is the caller graph for this function:

uint64_t rocksdb::BitStreamGetInt	(	const std::string *	src,
		size_t	offset,
		uint32_t	bits
	)

Definition at line 308 of file coding.cc.

References BitStreamGetInt().

                                        {
  return BitStreamGetInt(src->data(), src->size(), offset, bits);
}

Here is the call graph for this function:

uint64_t rocksdb::BitStreamGetInt	(	const Slice *	src,
		size_t	offset,
		uint32_t	bits
	)

Definition at line 313 of file coding.cc.

References BitStreamGetInt(), rocksdb::Slice::data(), and rocksdb::Slice::size().

                                        {
  return BitStreamGetInt(src->data(), src->size(), offset, bits);
}

Here is the call graph for this function:

void rocksdb::BitStreamPutInt	(	char *	dst,
		size_t	dstlen,
		size_t	offset,
		uint32_t	bits,
		uint64_t	value
	)

Definition at line 220 of file coding.cc.

References BitStreamGetInt(), and value.

Referenced by BitStreamPutInt(), and TEST().

                                                    {
  assert((offset + bits + 7)/8 <= dstlen);
  assert(bits <= 64);

  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);

  size_t byteOffset = offset / 8;
  size_t bitOffset = offset % 8;

  // This prevents unused variable warnings when compiling.
#ifndef NDEBUG
  // Store truncated value.
  uint64_t origValue = (bits < 64)?(value & (((uint64_t)1 << bits) - 1)):value;
  uint32_t origBits = bits;
#endif

  while (bits > 0) {
    size_t bitsToGet = std::min<size_t>(bits, 8 - bitOffset);
    unsigned char mask = ((1 << bitsToGet) - 1);

    ptr[byteOffset] = (ptr[byteOffset] & ~(mask << bitOffset)) +
                      ((value & mask) << bitOffset);

    value >>= bitsToGet;
    byteOffset += 1;
    bitOffset = 0;
    bits -= bitsToGet;
  }

  assert(origValue == BitStreamGetInt(dst, dstlen, offset, origBits));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::BitStreamPutInt	(	std::string *	dst,
		size_t	offset,
		uint32_t	bits,
		uint64_t	value
	)

Definition at line 281 of file coding.cc.

References BitStreamGetInt(), BitStreamPutInt(), and value.

                                     {
  assert((offset + bits + 7)/8 <= dst->size());

  const size_t kTmpBufLen = sizeof(value) + 1;
  char tmpBuf[kTmpBufLen];

  // Number of bytes of tmpBuf being used
  const size_t kUsedBytes = (offset%8 + bits)/8;

  // Copy relevant parts of dst to tmpBuf
  for (size_t idx = 0; idx <= kUsedBytes; ++idx) {
    tmpBuf[idx] = (*dst)[offset/8 + idx];
  }

  BitStreamPutInt(tmpBuf, kTmpBufLen, offset%8, bits, value);

  // Copy tmpBuf back to dst
  for (size_t idx = 0; idx <= kUsedBytes; ++idx) {
    (*dst)[offset/8 + idx] = tmpBuf[idx];
  }

  // Do the check here too as we are working with a buffer.
  assert(((bits < 64)?(value & (((uint64_t)1 << bits) - 1)):value) ==
         BitStreamGetInt(dst, offset, bits));
}

Here is the call graph for this function:

void rocksdb::BM_LogAndApply	(	int	iters,
		int	num_base_files
	)

Definition at line 4863 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, BytewiseComparator(), rocksdb::Options::create_if_missing, db, dbname, rocksdb::Env::Default(), rocksdb::VersionEdit::DeleteFile(), DestroyDB(), env, kTypeDeletion, kTypeValue, rocksdb::VersionSet::LogAndApply(), MakeKey(), mu, rocksdb::Env::NowMicros(), rocksdb::VersionSet::NumberLevels(), rocksdb::DB::Open(), rocksdb::VersionSet::Recover(), and rocksdb::test::TmpDir().

Referenced by main().

                                                   {
  std::string dbname = test::TmpDir() + "/rocksdb_test_benchmark";
  ASSERT_OK(DestroyDB(dbname, Options()));

  DB* db = nullptr;
  Options opts;
  opts.create_if_missing = true;
  Status s = DB::Open(opts, dbname, &db);
  ASSERT_OK(s);
  ASSERT_TRUE(db != nullptr);

  delete db;
  db = nullptr;

  Env* env = Env::Default();

  port::Mutex mu;
  MutexLock l(&mu);

  InternalKeyComparator cmp(BytewiseComparator());
  Options options;
  EnvOptions sopt;
  VersionSet vset(dbname, &options, sopt, nullptr, &cmp);
  ASSERT_OK(vset.Recover());
  VersionEdit vbase(vset.NumberLevels());
  uint64_t fnum = 1;
  for (int i = 0; i < num_base_files; i++) {
    InternalKey start(MakeKey(2*fnum), 1, kTypeValue);
    InternalKey limit(MakeKey(2*fnum+1), 1, kTypeDeletion);
    vbase.AddFile(2, fnum++, 1 /* file size */, start, limit, 1, 1);
  }
  ASSERT_OK(vset.LogAndApply(&vbase, &mu));

  uint64_t start_micros = env->NowMicros();

  for (int i = 0; i < iters; i++) {
    VersionEdit vedit(vset.NumberLevels());
    vedit.DeleteFile(2, fnum);
    InternalKey start(MakeKey(2*fnum), 1, kTypeValue);
    InternalKey limit(MakeKey(2*fnum+1), 1, kTypeDeletion);
    vedit.AddFile(2, fnum++, 1 /* file size */, start, limit, 1, 1);
    vset.LogAndApply(&vedit, &mu);
  }
  uint64_t stop_micros = env->NowMicros();
  unsigned int us = stop_micros - start_micros;
  char buf[16];
  snprintf(buf, sizeof(buf), "%d", num_base_files);
  fprintf(stderr,
          "BM_LogAndApply/%-6s   %8d iters : %9u us (%7.0f us / iter)\n",
          buf, iters, us, ((float)us) / iters);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Status rocksdb::BuildTable	(	const std::string &	dbname,
		Env *	env,
		const Options &	options,
		const EnvOptions &	soptions,
		TableCache *	table_cache,
		Iterator *	iter,
		FileMetaData *	meta,
		const Comparator *	user_comparator,
		const SequenceNumber	newest_snapshot,
		const SequenceNumber	earliest_seqno_in_memtable,
		const bool	enable_compression
	)

Definition at line 35 of file builder.cc.

References rocksdb::TableBuilder::Abandon(), rocksdb::TableBuilder::Add(), rocksdb::WritableFile::Close(), rocksdb::Comparator::Compare(), rocksdb::Options::compression, rocksdb::Slice::data(), rocksdb::InternalKey::DecodeFrom(), rocksdb::Env::DeleteFile(), rocksdb::Options::disableDataSync, rocksdb::FileMetaData::file_size, rocksdb::TableBuilder::FileSize(), rocksdb::TableBuilder::Finish(), rocksdb::WritableFile::Fsync(), GetInternalKeySeqno(), GetTableBuilder(), rocksdb::Options::info_log, rocksdb::Iterator::key(), kTypeMerge, rocksdb::FileMetaData::largest, rocksdb::FileMetaData::largest_seqno, ripple::max(), rocksdb::Options::merge_operator, ripple::min(), rocksdb::TableCache::NewIterator(), rocksdb::Env::NewWritableFile(), rocksdb::Iterator::Next(), rocksdb::FileMetaData::number, ripple::Resource::ok, rocksdb::Status::ok(), ParseInternalKey(), rocksdb::Options::purge_redundant_kvs_while_flush, rocksdb::Iterator::SeekToFirst(), rocksdb::ParsedInternalKey::sequence, rocksdb::Slice::size(), rocksdb::FileMetaData::smallest, rocksdb::FileMetaData::smallest_seqno, rocksdb::Options::statistics, rocksdb::Iterator::status(), rocksdb::WritableFile::Sync(), TABLE_SYNC_MICROS, TableFileName(), rocksdb::ParsedInternalKey::type, rocksdb::Options::use_fsync, rocksdb::ParsedInternalKey::user_key, rocksdb::Iterator::Valid(), rocksdb::Iterator::value(), and value.

Referenced by rocksdb::DBImpl::WriteLevel0Table(), and rocksdb::DBImpl::WriteLevel0TableForRecovery().

                                                 {
  Status s;
  meta->file_size = 0;
  meta->smallest_seqno = meta->largest_seqno = 0;
  iter->SeekToFirst();

  // If the sequence number of the smallest entry in the memtable is
  // smaller than the most recent snapshot, then we do not trigger
  // removal of duplicate/deleted keys as part of this builder.
  bool purge = options.purge_redundant_kvs_while_flush;
  if (earliest_seqno_in_memtable <= newest_snapshot) {
    purge = false;
  }

  std::string fname = TableFileName(dbname, meta->number);
  if (iter->Valid()) {
    unique_ptr<WritableFile> file;
    s = env->NewWritableFile(fname, &file, soptions);
    if (!s.ok()) {
      return s;
    }

    TableBuilder* builder = GetTableBuilder(options, file.get(),
                                            options.compression);

    // the first key is the smallest key
    Slice key = iter->key();
    meta->smallest.DecodeFrom(key);
    meta->smallest_seqno = GetInternalKeySeqno(key);
    meta->largest_seqno = meta->smallest_seqno;

    MergeHelper merge(user_comparator, options.merge_operator.get(),
                      options.info_log.get(),
                      true /* internal key corruption is not ok */);

    if (purge) {
      // Ugly walkaround to avoid compiler error for release build
      bool ok __attribute__((unused)) = true;

      // Will write to builder if current key != prev key
      ParsedInternalKey prev_ikey;
      std::string prev_key;
      bool is_first_key = true;    // Also write if this is the very first key

      while (iter->Valid()) {
        bool iterator_at_next = false;

        // Get current key
        ParsedInternalKey this_ikey;
        Slice key = iter->key();
        Slice value = iter->value();

        // In-memory key corruption is not ok;
        // TODO: find a clean way to treat in memory key corruption
        ok = ParseInternalKey(key, &this_ikey);
        assert(ok);
        assert(this_ikey.sequence >= earliest_seqno_in_memtable);

        // If the key is the same as the previous key (and it is not the
        // first key), then we skip it, since it is an older version.
        // Otherwise we output the key and mark it as the "new" previous key.
        if (!is_first_key && !user_comparator->Compare(prev_ikey.user_key,
                                                       this_ikey.user_key)) {
          // seqno within the same key are in decreasing order
          assert(this_ikey.sequence < prev_ikey.sequence);
        } else {
          is_first_key = false;

          if (this_ikey.type == kTypeMerge) {
            // Handle merge-type keys using the MergeHelper
            merge.MergeUntil(iter, 0 /* don't worry about snapshot */);
            iterator_at_next = true;
            if (merge.IsSuccess()) {
              // Merge completed correctly.
              // Add the resulting merge key/value and continue to next
              builder->Add(merge.key(), merge.value());
              prev_key.assign(merge.key().data(), merge.key().size());
              ok = ParseInternalKey(Slice(prev_key), &prev_ikey);
              assert(ok);
            } else {
              // Merge did not find a Put/Delete.
              // Can not compact these merges into a kValueType.
              // Write them out one-by-one. (Proceed back() to front())
              const std::deque<std::string>& keys = merge.keys();
              const std::deque<std::string>& values = merge.values();
              assert(keys.size() == values.size() && keys.size() >= 1);
              std::deque<std::string>::const_reverse_iterator key_iter;
              std::deque<std::string>::const_reverse_iterator value_iter;
              for (key_iter=keys.rbegin(), value_iter = values.rbegin();
                   key_iter != keys.rend() && value_iter != values.rend();
                   ++key_iter, ++value_iter) {

                builder->Add(Slice(*key_iter), Slice(*value_iter));
              }

              // Sanity check. Both iterators should end at the same time
              assert(key_iter == keys.rend() && value_iter == values.rend());

              prev_key.assign(keys.front());
              ok = ParseInternalKey(Slice(prev_key), &prev_ikey);
              assert(ok);
            }
          } else {
            // Handle Put/Delete-type keys by simply writing them
            builder->Add(key, value);
            prev_key.assign(key.data(), key.size());
            ok = ParseInternalKey(Slice(prev_key), &prev_ikey);
            assert(ok);
          }
        }

        if (!iterator_at_next) iter->Next();
      }

      // The last key is the largest key
      meta->largest.DecodeFrom(Slice(prev_key));
      SequenceNumber seqno = GetInternalKeySeqno(Slice(prev_key));
      meta->smallest_seqno = std::min(meta->smallest_seqno, seqno);
      meta->largest_seqno = std::max(meta->largest_seqno, seqno);

    } else {
      for (; iter->Valid(); iter->Next()) {
        Slice key = iter->key();
        meta->largest.DecodeFrom(key);
        builder->Add(key, iter->value());
        SequenceNumber seqno = GetInternalKeySeqno(key);
        meta->smallest_seqno = std::min(meta->smallest_seqno, seqno);
        meta->largest_seqno = std::max(meta->largest_seqno, seqno);
      }
    }

    // Finish and check for builder errors
    if (s.ok()) {
      s = builder->Finish();
      if (s.ok()) {
        meta->file_size = builder->FileSize();
        assert(meta->file_size > 0);
      }
    } else {
      builder->Abandon();
    }
    delete builder;

    // Finish and check for file errors
    if (s.ok() && !options.disableDataSync) {
      if (options.use_fsync) {
        StopWatch sw(env, options.statistics, TABLE_SYNC_MICROS);
        s = file->Fsync();
      } else {
        StopWatch sw(env, options.statistics, TABLE_SYNC_MICROS);
        s = file->Sync();
      }
    }
    if (s.ok()) {
      s = file->Close();
    }

    if (s.ok()) {
      // Verify that the table is usable
      Iterator* it = table_cache->NewIterator(ReadOptions(),
                                              soptions,
                                              meta->number,
                                              meta->file_size);
      s = it->status();
      delete it;
    }
  }

  // Check for input iterator errors
  if (!iter->status().ok()) {
    s = iter->status();
  }

  if (s.ok() && meta->file_size > 0) {
    // Keep it
  } else {
    env->DeleteFile(fname);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::bulk_load_

(

false

)

Referenced by compact_().

Here is the caller graph for this function:

void rocksdb::BumpPerfCount ( uint64_t *  count, uint64_t  delta = 1  )

inline

Definition at line 20 of file perf_context_imp.h.

References kEnableCount, and perf_level.

Referenced by rocksdb::BlockBasedTable::BlockReader(), rocksdb::InternalKeyComparator::Compare(), and ReadBlockContents().

                                                               {
  if (perf_level >= PerfLevel::kEnableCount) {
    *count += delta;
  }
}

Here is the caller graph for this function:

void rocksdb::BumpPerfTime ( uint64_t *  time, StopWatchNano *  timer, bool  reset = true  )

inline

Definition at line 26 of file perf_context_imp.h.

References rocksdb::StopWatchNano::ElapsedNanos(), kEnableTime, and perf_level.

Referenced by ReadBlockContents(), and rocksdb::DBImpl::Write().

                                            {
  if (perf_level >= PerfLevel::kEnableTime) {
    *time += timer->ElapsedNanos(reset);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Comparator * rocksdb::BytewiseComparator

(

)

Definition at line 81 of file comparator.cc.

References bytewise, InitModule(), rocksdb::port::InitOnce(), and once.

Referenced by BM_LogAndApply(), Do_Compression_Test(), rocksdb::FindFileTest::Find(), rocksdb::BlockBasedTableBuilder::Finish(), Increment(), rocksdb::FindFileTest::Overlaps(), PrintContents(), rocksdb::BlockBasedTable::ReadMetaBlock(), rocksdb::BlockBasedTable::ReadProperties(), rocksdb::SstFileReader::ReadSequential(), Shorten(), ShortSuccessor(), and TEST().

                                       {
  port::InitOnce(&once, InitModule);
  return bytewise;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::BZip2CompressionSupported ( const CompressionOptions &  options)

static

Definition at line 46 of file db_test.cc.

References rocksdb::port::BZip2_Compress(), rocksdb::Slice::data(), Json::in(), and rocksdb::Slice::size().

Referenced by GenerateArgList(), and MinLevelToCompress().

                                                                         {
  std::string out;
  Slice in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  return port::BZip2_Compress(options, in.data(), in.size(), &out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class V >

static void rocksdb::ClipToRange ( T *  ptr, V  minvalue, V  maxvalue  )

static

Definition at line 116 of file db_impl.cc.

Referenced by SanitizeOptions().

                                                        {
  if (static_cast<V>(*ptr) > maxvalue) *ptr = maxvalue;
  if (static_cast<V>(*ptr) < minvalue) *ptr = minvalue;
}

Here is the caller graph for this function:

rocksdb::compact_

(

false

)

Definition at line 399 of file ldb_cmd.cc.

References bulk_load_(), create_if_missing_(), and disable_wal_().

                    {

  create_if_missing_ = IsFlagPresent(flags, ARG_CREATE_IF_MISSING);
  disable_wal_ = IsFlagPresent(flags, ARG_DISABLE_WAL);
  bulk_load_ = IsFlagPresent(flags, ARG_BULK_LOAD);
  compact_ = IsFlagPresent(flags, ARG_COMPACT);
}

Here is the call graph for this function:

static bool rocksdb::CompareIterators ( int  step, DB *  model, DB *  db, const Snapshot *  model_snap, const Snapshot *  db_snap  )

static

Definition at line 4542 of file db_test.cc.

References rocksdb::Slice::compare(), EscapeString(), rocksdb::Iterator::key(), rocksdb::DB::NewIterator(), rocksdb::Iterator::Next(), ripple::Resource::ok, rocksdb::Iterator::SeekToFirst(), rocksdb::ReadOptions::snapshot, rocksdb::Iterator::Valid(), and rocksdb::Iterator::value().

Referenced by TEST().

                                                      {
  ReadOptions options;
  options.snapshot = model_snap;
  Iterator* miter = model->NewIterator(options);
  options.snapshot = db_snap;
  Iterator* dbiter = db->NewIterator(options);
  bool ok = true;
  int count = 0;
  for (miter->SeekToFirst(), dbiter->SeekToFirst();
       ok && miter->Valid() && dbiter->Valid();
       miter->Next(), dbiter->Next()) {
    count++;
    if (miter->key().compare(dbiter->key()) != 0) {
      fprintf(stderr, "step %d: Key mismatch: '%s' vs. '%s'\n",
              step,
              EscapeString(miter->key()).c_str(),
              EscapeString(dbiter->key()).c_str());
      ok = false;
      break;
    }

    if (miter->value().compare(dbiter->value()) != 0) {
      fprintf(stderr, "step %d: Value mismatch for key '%s': '%s' vs. '%s'\n",
              step,
              EscapeString(miter->key()).c_str(),
              EscapeString(miter->value()).c_str(),
              EscapeString(miter->value()).c_str());
      ok = false;
    }
  }

  if (ok) {
    if (miter->Valid() != dbiter->Valid()) {
      fprintf(stderr, "step %d: Mismatch at end of iterators: %d vs. %d\n",
              step, miter->Valid(), dbiter->Valid());
      ok = false;
    }
  }
  delete miter;
  delete dbiter;
  return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::compareSeqnoDescending ( const VersionSet::Fsize &  first, const VersionSet::Fsize &  second  )

static

Definition at line 1765 of file version_set.cc.

References rocksdb::VersionSet::fsize::file, rocksdb::FileMetaData::largest_seqno, and rocksdb::FileMetaData::smallest_seqno.

Referenced by rocksdb::VersionSet::UpdateFilesBySize().

                                 {
  if (first.file->smallest_seqno > second.file->smallest_seqno) {
    assert(first.file->largest_seqno > second.file->largest_seqno);
    return true;
  }
  assert(first.file->largest_seqno <= second.file->largest_seqno);
  return false;
}

Here is the caller graph for this function:

static bool rocksdb::compareSizeDescending ( const VersionSet::Fsize &  first, const VersionSet::Fsize &  second  )

static

Definition at line 1759 of file version_set.cc.

References rocksdb::VersionSet::fsize::file, and rocksdb::FileMetaData::file_size.

Referenced by rocksdb::VersionSet::UpdateFilesBySize().

                                 {
  return (first.file->file_size > second.file->file_size);
}

Here is the caller graph for this function:

static void rocksdb::ConcurrentReader ( void *  arg)

static

Definition at line 341 of file skiplist_test.cc.

References rocksdb::port::AtomicPointer::Acquire_Load(), arg, rocksdb::TestState::Change(), rocksdb::TestState::DONE, rocksdb::TestState::quit_flag_, rocksdb::ConcurrentTest::ReadStep(), rocksdb::TestState::RUNNING, rocksdb::TestState::seed_, and rocksdb::TestState::t_.

Referenced by RunConcurrent().

                                        {
  TestState* state = reinterpret_cast<TestState*>(arg);
  Random rnd(state->seed_);
  int64_t reads = 0;
  state->Change(TestState::RUNNING);
  while (!state->quit_flag_.Acquire_Load()) {
    state->t_.ReadStep(&rnd);
    ++reads;
  }
  state->Change(TestState::DONE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rocksdb::ConsumeChar	(	Slice *	in,
		char	c
	)

Definition at line 53 of file logging.cc.

References rocksdb::Slice::empty(), and rocksdb::Slice::remove_prefix().

                                    {
  if (!in->empty() && (*in)[0] == c) {
    in->remove_prefix(1);
    return true;
  } else {
    return false;
  }
}

Here is the call graph for this function:

bool rocksdb::ConsumeDecimalNumber	(	Slice *	in,
		uint64_t *	val
	)

Definition at line 62 of file logging.cc.

References rocksdb::Slice::empty(), and rocksdb::Slice::remove_prefix().

Referenced by rocksdb::CorruptionTest::Check(), rocksdb::DBImpl::GetProperty(), and ParseFileName().

                                                    {
  uint64_t v = 0;
  int digits = 0;
  while (!in->empty()) {
    char c = (*in)[0];
    if (c >= '0' && c <= '9') {
      ++digits;
      const unsigned int delta = (c - '0');
      static const uint64_t kMaxUint64 = ~static_cast<uint64_t>(0);
      if (v > kMaxUint64/10 ||
          (v == kMaxUint64/10 && delta > kMaxUint64%10)) {
        // Overflow
        return false;
      }
      v = (v * 10) + delta;
      in->remove_prefix(1);
    } else {
      break;
    }
  }
  *val = v;
  return (digits > 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::count_delim_

(

false

)

Referenced by is_input_key_hex_(), and print_stats_().

Here is the caller graph for this function:

rocksdb::count_only_

(

false

)

Referenced by is_input_key_hex_(), and print_stats_().

Here is the caller graph for this function:

rocksdb::create_if_missing_

(

false

)

Referenced by compact_().

Here is the caller graph for this function:

std::shared_ptr< Statistics > rocksdb::CreateDBStatistics

(

)

Definition at line 61 of file db_statistics.h.

Referenced by main(), and TEST().

                                               {
  return std::make_shared<DBStatistics>();
}

Here is the caller graph for this function:

Status rocksdb::CreateLoggerFromOptions	(	const std::string &	dbname,
		const std::string &	db_log_dir,
		Env *	env,
		const Options &	options,
		std::shared_ptr< Logger > *	logger
	)

Definition at line 76 of file auto_roll_logger.cc.

References rocksdb::Env::CreateDir(), rocksdb::Env::GetAbsolutePath(), rocksdb::AutoRollLogger::GetStatus(), InfoLogFileName(), rocksdb::Options::log_file_time_to_roll, rocksdb::Options::max_log_file_size, rocksdb::Env::NewLogger(), rocksdb::Env::NowMicros(), rocksdb::Status::ok(), OldInfoLogFileName(), and rocksdb::Env::RenameFile().

Referenced by SanitizeOptions(), and TEST().

                                   {
  std::string db_absolute_path;
  env->GetAbsolutePath(dbname, &db_absolute_path);
  std::string fname = InfoLogFileName(dbname, db_absolute_path, db_log_dir);

  // Currently we only support roll by time-to-roll and log size
  if (options.log_file_time_to_roll > 0 || options.max_log_file_size > 0) {
    AutoRollLogger* result = new AutoRollLogger(
        env, dbname, db_log_dir,
        options.max_log_file_size,
        options.log_file_time_to_roll);
    Status s = result->GetStatus();
    if (!s.ok()) {
      delete result;
    } else {
      logger->reset(result);
    }
    return s;
  } else {
    // Open a log file in the same directory as the db
    env->CreateDir(dbname);  // In case it does not exist
    env->RenameFile(fname, OldInfoLogFileName(dbname, env->NowMicros(),
                                              db_absolute_path, db_log_dir));
    return env->NewLogger(fname, logger);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::CurrentFileName

(

const std::string &

dbname)

Definition at line 86 of file filename.cc.

Referenced by rocksdb::DBImpl::GetLiveFiles(), rocksdb::DBImpl::Recover(), rocksdb::VersionSet::Recover(), SetCurrentFile(), and TEST().

                                                   {
  return dbname + "/CURRENT";
}

Here is the caller graph for this function:

static const char* rocksdb::DecodeEntry ( const char *  p, const char *  limit, uint32_t *  shared, uint32_t *  non_shared, uint32_t *  value_length  )

inlinestatic

Definition at line 59 of file block.cc.

References GetVarint32Ptr().

Referenced by rocksdb::Block::Iter::ParseNextKey(), and rocksdb::Block::Iter::Seek().

                                                              {
  if (limit - p < 3) return nullptr;
  *shared = reinterpret_cast<const unsigned char*>(p)[0];
  *non_shared = reinterpret_cast<const unsigned char*>(p)[1];
  *value_length = reinterpret_cast<const unsigned char*>(p)[2];
  if ((*shared | *non_shared | *value_length) < 128) {
    // Fast path: all three values are encoded in one byte each
    p += 3;
  } else {
    if ((p = GetVarint32Ptr(p, limit, shared)) == nullptr) return nullptr;
    if ((p = GetVarint32Ptr(p, limit, non_shared)) == nullptr) return nullptr;
    if ((p = GetVarint32Ptr(p, limit, value_length)) == nullptr) return nullptr;
  }

  if (static_cast<uint32_t>(limit - p) < (*non_shared + *value_length)) {
    return nullptr;
  }
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t rocksdb::DecodeFixed32 ( const char *  ptr)

inline

Definition at line 67 of file coding.h.

References rocksdb::port::kLittleEndian.

Referenced by rocksdb::Blob::Blob(), rocksdb::WriteBatchInternal::Count(), DecodeFixed64(), rocksdb::Footer::DecodeFrom(), DecodeKey(), rocksdb::FilterBlockReader::FilterBlockReader(), rocksdb::Block::Iter::GetRestartPoint(), Hash(), rocksdb::DBWithTTL::IsStale(), rocksdb::TestHashFilter::KeyMayMatch(), rocksdb::crc32c::LE_LOAD32(), rocksdb::FilterBlockReader::MayMatch(), rocksdb::RedisListIterator::MoveNext(), rocksdb::SimpleTableIterator::Next(), rocksdb::Block::NumRestarts(), ReadBlockContents(), rocksdb::log::Reader::ReadPhysicalRecord(), rocksdb::RedisListIterator::RedisListIterator(), rocksdb::DBWithTTL::SanityCheckTimestamp(), TEST(), and rocksdb::TtlIterator::timestamp().

                                               {
  if (port::kLittleEndian) {
    // Load the raw bytes
    uint32_t result;
    memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
    return result;
  } else {
    return ((static_cast<uint32_t>(static_cast<unsigned char>(ptr[0])))
        | (static_cast<uint32_t>(static_cast<unsigned char>(ptr[1])) << 8)
        | (static_cast<uint32_t>(static_cast<unsigned char>(ptr[2])) << 16)
        | (static_cast<uint32_t>(static_cast<unsigned char>(ptr[3])) << 24));
  }
}

Here is the caller graph for this function:

uint64_t rocksdb::DecodeFixed64 ( const char *  ptr)

inline

Definition at line 81 of file coding.h.

References DecodeFixed32(), and rocksdb::port::kLittleEndian.

Referenced by rocksdb::InternalKeyComparator::Compare(), dumpDb(), ExtractValueType(), rocksdb::MemTable::Get(), Counters::get(), GetFileIterator(), GetInternalKeySeqno(), rocksdb::SimpleTableReader::GetOffset(), rocksdb::crc32c::LE_LOAD64(), rocksdb::SimpleTableReader::Open(), ParseInternalKey(), rocksdb::Version::PrefixMayMatch(), rocksdb::WriteBatchInternal::Sequence(), TEST(), and rocksdb::MemTable::Update().

                                               {
  if (port::kLittleEndian) {
    // Load the raw bytes
    uint64_t result;
    memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
    return result;
  } else {
    uint64_t lo = DecodeFixed32(ptr);
    uint64_t hi = DecodeFixed32(ptr + 4);
    return (hi << 32) | lo;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int rocksdb::DecodeKey ( const Slice &  k)

static

Definition at line 26 of file cache_test.cc.

References rocksdb::Slice::data(), DecodeFixed32(), and rocksdb::Slice::size().

Referenced by rocksdb::CacheTest::Deleter().

                                     {
  assert(k.size() == 4);
  return DecodeFixed32(k.data());
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int rocksdb::DecodeValue ( void *  v)

static

Definition at line 31 of file cache_test.cc.

Referenced by rocksdb::CacheTest::Deleter(), rocksdb::CacheTest::Lookup(), and TEST().

{ return reinterpret_cast<uintptr_t>(v); }

Here is the caller graph for this function:

static void rocksdb::DeleteCachedBlock ( const Slice &  key, void *  value  )

static

Definition at line 308 of file block_based_table_builder.cc.

References value.

Referenced by rocksdb::BlockBasedTable::BlockReader(), rocksdb::BlockBasedTable::GetBlock(), and rocksdb::BlockBasedTableBuilder::InsertBlockInCache().

                                                             {
  Block* block = reinterpret_cast<Block*>(value);
  delete block;
}

Here is the caller graph for this function:

static void rocksdb::DeleteEntry ( const Slice &  key, void *  value  )

static

Definition at line 21 of file table_cache.cc.

References value.

Referenced by rocksdb::TableCache::FindTable().

                                                       {
  TableReader* table_reader = reinterpret_cast<TableReader*>(value);
  delete table_reader;
}

Here is the caller graph for this function:

void rocksdb::deleter	(	const Slice &	key,
		void *	value
	)

Definition at line 352 of file cache_test.cc.

Referenced by TEST().

                                            {
  delete (Value *)value;
}

Here is the caller graph for this function:

rocksdb::delim_

(

"."

)

Referenced by is_input_key_hex_(), and print_stats_().

Here is the caller graph for this function:

std::string rocksdb::DescriptorFileName	(	const std::string &	dbname,
		uint64_t	number
	)

Definition at line 78 of file filename.cc.

Referenced by rocksdb::DBImpl::GetLiveFiles(), rocksdb::VersionSet::LogAndApply(), rocksdb::VersionSet::ManifestContains(), rocksdb::DBImpl::NewDB(), SetCurrentFile(), and TEST().

                                                                       {
  assert(number > 0);
  char buf[100];
  snprintf(buf, sizeof(buf), "/MANIFEST-%06llu",
           static_cast<unsigned long long>(number));
  return dbname + buf;
}

Here is the caller graph for this function:

Status rocksdb::DestroyDB	(	const std::string &	dbname,
		const Options &	options
	)

Definition at line 3524 of file db_impl.cc.

References ArchivalDirectory(), comparator, rocksdb::Options::comparator, rocksdb::Env::DeleteDir(), rocksdb::Env::DeleteFile(), env, rocksdb::Options::env, rocksdb::Options::filter_policy, rocksdb::Env::GetChildren(), kDBLockFile, kLogFile, kMetaDatabase, rocksdb::Env::LockFile(), LockFileName(), rocksdb::Status::OK(), rocksdb::Status::ok(), ParseFileName(), SanitizeOptions(), rocksdb::Env::UnlockFile(), and rocksdb::Options::wal_dir.

Referenced by rocksdb::Benchmark::Benchmark(), BM_LogAndApply(), rocksdb::CorruptionTest::CorruptionTest(), rocksdb::DBTest::DBTest(), rocksdb::DeleteFileTest::DeleteFileTest(), rocksdb::DBTest::Destroy(), rocksdb::SimpleTableDBTest::Destroy(), leveldb_destroy_db(), main(), rocksdb::DBConstructor::NewDB(), OpenDb(), ProfileKeyComparison(), rocksdb::RedisLists::RedisLists(), rocksdb::ReduceLevelTest::ReduceLevelTest(), rocksdb::DeleteFileTest::ReopenDB(), rocksdb::Benchmark::Run(), runTest(), rocksdb::SimpleTableDBTest::SimpleTableDBTest(), rocksdb::StressTest::StressTest(), rocksdb::StringAppendOperatorTest::StringAppendOperatorTest(), TableReaderBenchmark(), TEST(), rocksdb::TtlTest::TtlTest(), rocksdb::CorruptionTest::~CorruptionTest(), rocksdb::DBTest::~DBTest(), rocksdb::SimpleTableDBTest::~SimpleTableDBTest(), and rocksdb::TtlTest::~TtlTest().

                                                                  {
  const InternalKeyComparator comparator(options.comparator);
  const InternalFilterPolicy filter_policy(options.filter_policy);
  const Options& soptions(SanitizeOptions(
    dbname, &comparator, &filter_policy, options));
  Env* env = soptions.env;
  std::vector<std::string> filenames;
  std::vector<std::string> archiveFiles;

  std::string archivedir = ArchivalDirectory(dbname);
  // Ignore error in case directory does not exist
  env->GetChildren(dbname, &filenames);

  if (dbname != soptions.wal_dir) {
    std::vector<std::string> logfilenames;
    env->GetChildren(soptions.wal_dir, &logfilenames);
    filenames.insert(filenames.end(), logfilenames.begin(), logfilenames.end());
    archivedir = ArchivalDirectory(soptions.wal_dir);
  }

  if (filenames.empty()) {
    return Status::OK();
  }

  FileLock* lock;
  const std::string lockname = LockFileName(dbname);
  Status result = env->LockFile(lockname, &lock);
  if (result.ok()) {
    uint64_t number;
    FileType type;
    for (size_t i = 0; i < filenames.size(); i++) {
      if (ParseFileName(filenames[i], &number, &type) &&
          type != kDBLockFile) {  // Lock file will be deleted at end
        Status del;
        if (type == kMetaDatabase) {
          del = DestroyDB(dbname + "/" + filenames[i], options);
        } else if (type == kLogFile) {
          del = env->DeleteFile(soptions.wal_dir + "/" + filenames[i]);
        } else {
          del = env->DeleteFile(dbname + "/" + filenames[i]);
        }
        if (result.ok() && !del.ok()) {
          result = del;
        }
      }
    }

    env->GetChildren(archivedir, &archiveFiles);
    // Delete archival files.
    for (size_t i = 0; i < archiveFiles.size(); ++i) {
      if (ParseFileName(archiveFiles[i], &number, &type) &&
          type == kLogFile) {
        Status del = env->DeleteFile(archivedir + "/" + archiveFiles[i]);
        if (result.ok() && !del.ok()) {
          result = del;
        }
      }
    }
    // ignore case where no archival directory is present.
    env->DeleteDir(archivedir);

    env->UnlockFile(lock);  // Ignore error since state is already gone
    env->DeleteFile(lockname);
    env->DeleteDir(dbname);  // Ignore error in case dir contains other files
    env->DeleteDir(soptions.wal_dir);
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::disable_wal_

(

false

)

Referenced by compact_().

Here is the caller graph for this function:

static void rocksdb::Do_Compression_Test ( CompressionType  comp)

static

Definition at line 1136 of file table_test.cc.

References rocksdb::Constructor::Add(), rocksdb::BlockBasedTableConstructor::ApproximateOffsetOf(), ASSERT_TRUE, Between(), rocksdb::Options::block_size, BytewiseComparator(), rocksdb::test::CompressibleString(), rocksdb::Options::compression, and rocksdb::Constructor::Finish().

Referenced by TEST().

                                                      {
  Random rnd(301);
  BlockBasedTableConstructor c(BytewiseComparator());
  std::string tmp;
  c.Add("k01", "hello");
  c.Add("k02", test::CompressibleString(&rnd, 0.25, 10000, &tmp));
  c.Add("k03", "hello3");
  c.Add("k04", test::CompressibleString(&rnd, 0.25, 10000, &tmp));
  std::vector<std::string> keys;
  KVMap kvmap;
  Options options;
  options.block_size = 1024;
  options.compression = comp;
  c.Finish(options, &keys, &kvmap);

  ASSERT_TRUE(Between(c.ApproximateOffsetOf("abc"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k02"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k03"),    2000,   3000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04"),    2000,   3000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("xyz"),    4000,   6000));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Status rocksdb::DoWriteStringToFile ( Env *  env, const Slice &  data, const std::string &  fname, bool  should_sync  )

static

Definition at line 63 of file env.cc.

References rocksdb::WritableFile::Append(), rocksdb::Env::DeleteFile(), rocksdb::Env::NewWritableFile(), rocksdb::Status::ok(), and rocksdb::WritableFile::Sync().

Referenced by WriteStringToFile(), and WriteStringToFileSync().

                                                    {
  unique_ptr<WritableFile> file;
  EnvOptions soptions;
  Status s = env->NewWritableFile(fname, &file, soptions);
  if (!s.ok()) {
    return s;
  }
  s = file->Append(data);
  if (s.ok() && should_sync) {
    s = file->Sync();
  }
  if (!s.ok()) {
    env->DeleteFile(fname);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::DummySaveValue ( void *  arg, const Slice &  ikey, const Slice &  v, bool  didIO  )

static

Definition at line 36 of file table_reader_bench.cc.

Referenced by TableReaderBenchmark().

                                       {
  return false;
}

Here is the caller graph for this function:

void rocksdb::dumpLeveldbBuildVersion

(

Logger *

log)

Referenced by rocksdb::DBImpl::DBImpl().

Here is the caller graph for this function:

void rocksdb::EncodeFixed32	(	char *	buf,
		uint32_t	value
	)

Definition at line 16 of file coding.cc.

Referenced by rocksdb::DBWithTTL::AppendTS(), rocksdb::log::Writer::EmitPhysicalRecord(), rocksdb::log::LogTest::FixChecksum(), rocksdb::TtlMergeOperator::FullMerge(), rocksdb::RedisListIterator::InsertElement(), rocksdb::TtlMergeOperator::PartialMerge(), PutFixed32(), rocksdb::WriteBatchInternal::SetCount(), rocksdb::BlockBasedTableBuilder::WriteRawBlock(), and rocksdb::RedisListIterator::WriteResult().

                                              {
#if __BYTE_ORDER == __LITTLE_ENDIAN
  memcpy(buf, &value, sizeof(value));
#else
  buf[0] = value & 0xff;
  buf[1] = (value >> 8) & 0xff;
  buf[2] = (value >> 16) & 0xff;
  buf[3] = (value >> 24) & 0xff;
#endif
}

Here is the caller graph for this function:

void rocksdb::EncodeFixed64	(	char *	buf,
		uint64_t	value
	)

Definition at line 27 of file coding.cc.

Referenced by rocksdb::MemTable::Add(), MergeBasedCounters::add(), rocksdb::TableCache::Evict(), rocksdb::TableCache::FindTable(), rocksdb::LookupKey::LookupKey(), PutFixed64(), rocksdb::WriteBatchInternal::SetSequence(), UpdateInternalKey(), and rocksdb::Version::LevelFileNumIterator::value().

                                              {
#if __BYTE_ORDER == __LITTLE_ENDIAN
  memcpy(buf, &value, sizeof(value));
#else
  buf[0] = value & 0xff;
  buf[1] = (value >> 8) & 0xff;
  buf[2] = (value >> 16) & 0xff;
  buf[3] = (value >> 24) & 0xff;
  buf[4] = (value >> 32) & 0xff;
  buf[5] = (value >> 40) & 0xff;
  buf[6] = (value >> 48) & 0xff;
  buf[7] = (value >> 56) & 0xff;
#endif
}

Here is the caller graph for this function:

static std::string rocksdb::EncodeKey ( int  k)

static

Definition at line 21 of file cache_test.cc.

References PutFixed32().

                                  {
  std::string result;
  PutFixed32(&result, k);
  return result;
}

Here is the call graph for this function:

static const char* rocksdb::EncodeKey ( std::string *  scratch, const Slice &  target  )

static

Definition at line 81 of file memtable.cc.

References rocksdb::Slice::data(), PutVarint32(), and rocksdb::Slice::size().

Referenced by rocksdb::CacheTest::Erase(), rocksdb::CacheTest::Insert(), rocksdb::CacheTest::Lookup(), rocksdb::MemTableIterator::Seek(), and TEST().

                                                                      {
  scratch->clear();
  PutVarint32(scratch, target.size());
  scratch->append(target.data(), target.size());
  return scratch->data();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void* rocksdb::EncodeValue ( uintptr_t  v)

static

Definition at line 30 of file cache_test.cc.

Referenced by rocksdb::CacheTest::Insert().

{ return reinterpret_cast<void*>(v); }

Here is the caller graph for this function:

char * rocksdb::EncodeVarint32	(	char *	dst,
		uint32_t	v
	)

Definition at line 54 of file coding.cc.

Referenced by rocksdb::MemTable::Add(), rocksdb::LookupKey::LookupKey(), PutVarint32(), and rocksdb::MemTable::Update().

                                            {
  // Operate on characters as unsigneds
  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
  static const int B = 128;
  if (v < (1<<7)) {
    *(ptr++) = v;
  } else if (v < (1<<14)) {
    *(ptr++) = v | B;
    *(ptr++) = v>>7;
  } else if (v < (1<<21)) {
    *(ptr++) = v | B;
    *(ptr++) = (v>>7) | B;
    *(ptr++) = v>>14;
  } else if (v < (1<<28)) {
    *(ptr++) = v | B;
    *(ptr++) = (v>>7) | B;
    *(ptr++) = (v>>14) | B;
    *(ptr++) = v>>21;
  } else {
    *(ptr++) = v | B;
    *(ptr++) = (v>>7) | B;
    *(ptr++) = (v>>14) | B;
    *(ptr++) = (v>>21) | B;
    *(ptr++) = v>>28;
  }
  return reinterpret_cast<char*>(ptr);
}

Here is the caller graph for this function:

char * rocksdb::EncodeVarint64	(	char *	dst,
		uint64_t	v
	)

Definition at line 88 of file coding.cc.

Referenced by rocksdb::BlockBasedTable::GenerateCachePrefix(), rocksdb::StringSource::GetUniqueId(), rocksdb::BlockBasedTableBuilder::InsertBlockInCache(), and PutVarint64().

                                            {
  static const unsigned int B = 128;
  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
  while (v >= B) {
    *(ptr++) = (v & (B-1)) | B;
    v >>= 7;
  }
  *(ptr++) = static_cast<unsigned char>(v);
  return reinterpret_cast<char*>(ptr);
}

Here is the caller graph for this function:

rocksdb::end_key_specified_

(

false

)

Referenced by max_keys_scanned_().

Here is the caller graph for this function:

std::string rocksdb::EscapeString

(

const Slice &

value)

Definition at line 47 of file logging.cc.

References AppendEscapedStringTo().

Referenced by CompareIterators(), rocksdb::InternalKey::DebugString(), TEST(), and rocksdb::Harness::TestRandomAccess().

                                           {
  std::string r;
  AppendEscapedStringTo(&r, value);
  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::ExpectRecords	(	const int	expected_no_records,
		std::unique_ptr< TransactionLogIterator > &	iter
	)

Definition at line 4011 of file db_test.cc.

References ASSERT_EQ, and ReadRecords().

Referenced by TEST().

                                                 {
  int num_records;
  ReadRecords(iter, num_records);
  ASSERT_EQ(num_records, expected_no_records);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Slice rocksdb::ExtractUserKey ( const Slice &  internal_key)

inline

Definition at line 75 of file dbformat.h.

References rocksdb::Slice::data(), and rocksdb::Slice::size().

Referenced by rocksdb::FilterBlockBuilder::AddKey(), rocksdb::InternalKeyComparator::Compare(), rocksdb::InternalFilterPolicy::CreateFilter(), rocksdb::InternalKeyComparator::FindShortestSeparator(), rocksdb::InternalKeyComparator::FindShortSuccessor(), rocksdb::InternalFilterPolicy::KeyMayMatch(), rocksdb::BlockBasedTable::PrefixMayMatch(), rocksdb::Version::PrefixMayMatch(), and rocksdb::InternalKey::user_key().

                                                       {
  assert(internal_key.size() >= 8);
  return Slice(internal_key.data(), internal_key.size() - 8);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ValueType rocksdb::ExtractValueType ( const Slice &  internal_key)

inline

Definition at line 80 of file dbformat.h.

References rocksdb::Slice::data(), DecodeFixed64(), and rocksdb::Slice::size().

                                                             {
  assert(internal_key.size() >= 8);
  const size_t n = internal_key.size();
  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
  unsigned char c = num & 0xff;
  return static_cast<ValueType>(c);
}

Here is the call graph for this function:

int rocksdb::FindFile	(	const InternalKeyComparator &	icmp,
		const std::vector< FileMetaData * > &	files,
		const Slice &	key
	)

Definition at line 60 of file version_set.cc.

References rocksdb::InternalKey::Encode(), ripple::f, and rocksdb::FileMetaData::largest.

Referenced by rocksdb::FindFileTest::Find(), rocksdb::Version::Get(), rocksdb::Version::HasOverlappingUserKey(), rocksdb::Version::LevelFileNumIterator::Seek(), and SomeFileOverlapsRange().

                               {
  uint32_t left = 0;
  uint32_t right = files.size();
  while (left < right) {
    uint32_t mid = (left + right) / 2;
    const FileMetaData* f = files[mid];
    if (icmp.InternalKeyComparator::Compare(f->largest.Encode(), key) < 0) {
      // Key at "mid.largest" is < "target".  Therefore all
      // files at or before "mid" are uninteresting.
      left = mid + 1;
    } else {
      // Key at "mid.largest" is >= "target".  Therefore all files
      // after "mid" are uninteresting.
      right = mid;
    }
  }
  return right;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int rocksdb::FlattenPath ( const std::string &  path, char *  dest, int  len  )

static

Definition at line 23 of file filename.cc.

Referenced by InfoLogFileName(), and OldInfoLogFileName().

                                                                   {
  int write_idx = 0;
  int i = 0;
  int src_len = path.size();

  while (i < src_len && write_idx < len - 1) {
    if ((path[i] >= 'a' && path[i] <= 'z') ||
        (path[i] >= '0' && path[i] <= '9') ||
        (path[i] >= 'A' && path[i] <= 'Z') ||
        path[i] == '-' ||
        path[i] == '.' ||
        path[i] == '_'){
      dest[write_idx++] = path[i];
    } else {
      if (i > 0)
        dest[write_idx++] = '_';
    }
    i++;
  }

  dest[write_idx] = '\0';
  return write_idx;
}

Here is the caller graph for this function:

static std::vector<TestArgs> rocksdb::GenerateArgList ( )

static

Definition at line 493 of file table_test.cc.

References BLOCK_TEST, BZip2CompressionSupported(), rocksdb::TestArgs::compression, DB_TEST, kBZip2Compression, kNoCompression, kSnappyCompression, kZlibCompression, MEMTABLE_TEST, rocksdb::TestArgs::restart_interval, rocksdb::TestArgs::reverse_compare, SnappyCompressionSupported(), TABLE_TEST, rocksdb::TestArgs::type, and ZlibCompressionSupported().

Referenced by TEST().

                                             {
  std::vector<TestArgs> ret;
  TestType test_type[4] = {TABLE_TEST, BLOCK_TEST, MEMTABLE_TEST, DB_TEST};
  int test_type_len = 4;
  bool reverse_compare[2] = {false, true};
  int reverse_compare_len = 2;
  int restart_interval[3] = {16, 1, 1024};
  int restart_interval_len = 3;

  // Only add compression if it is supported
  std::vector<CompressionType> compression_types;
  compression_types.push_back(kNoCompression);
#ifdef SNAPPY
  if (SnappyCompressionSupported())
    compression_types.push_back(kSnappyCompression);
#endif

#ifdef ZLIB
  if (ZlibCompressionSupported())
    compression_types.push_back(kZlibCompression);
#endif

#ifdef BZIP2
  if (BZip2CompressionSupported())
    compression_types.push_back(kBZip2Compression);
#endif

  for(int i =0; i < test_type_len; i++)
    for (int j =0; j < reverse_compare_len; j++)
      for (int k =0; k < restart_interval_len; k++)
  for (unsigned int n =0; n < compression_types.size(); n++) {
    TestArgs one_arg;
    one_arg.type = test_type[i];
    one_arg.reverse_compare = reverse_compare[j];
    one_arg.restart_interval = restart_interval[k];
    one_arg.compression = compression_types[n];
    ret.push_back(one_arg);
  }

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CompressionType rocksdb::GetCompressionType	(	const Options &	options,
		int	level,
		const bool	enable_compression
	)

Definition at line 205 of file db_impl.cc.

References rocksdb::Options::compression, rocksdb::Options::compression_per_level, kNoCompression, ripple::max(), and ripple::min().

Referenced by rocksdb::DBImpl::OpenCompactionOutputFile().

                                                                  {
  if (!enable_compression) {
    // disable compression
    return kNoCompression;
  }
  // If the use has specified a different compression level for each level,
  // then pick the compresison for that level.
  if (!options.compression_per_level.empty()) {
    const int n = options.compression_per_level.size() - 1;
    // It is possible for level_ to be -1; in that case, we use level
    // 0's compression.  This occurs mostly in backwards compatibility
    // situations when the builder doesn't know what level the file
    // belongs to.  Likewise, if level_ is beyond the end of the
    // specified compression levels, use the last value.
    return options.compression_per_level[std::max(0, std::min(level, n))];
  } else {
    return options.compression;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t rocksdb::GetDeletedKeys

(

const TableProperties::UserCollectedProperties &

props)

Definition at line 153 of file table_properties_collector.cc.

References GetVarint64(), and rocksdb::InternalKeyTablePropertiesNames::kDeletedKeys.

Referenced by TEST().

                                                         {
  auto pos = props.find(InternalKeyTablePropertiesNames::kDeletedKeys);
  if (pos == props.end()) {
    return 0;
  }
  Slice raw = pos->second;
  uint64_t val = 0;
  return GetVarint64(&raw, &val) ? val : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::GetFileCreateTime	(	const std::string &	fname,
		uint64_t *	file_ctime
	)

Definition at line 56 of file auto_roll_logger_test.cc.

Referenced by rocksdb::AutoRollLoggerTest::RollLogFileByTimeTest().

                                                                     {
  struct stat s;
  if (stat(fname.c_str(), &s) != 0) {
    *file_ctime = (uint64_t)0;
  }
  *file_ctime = static_cast<uint64_t>(s.st_ctime);
}

Here is the caller graph for this function:

static Iterator* rocksdb::GetFileIterator ( void *  arg, const ReadOptions &  options, const EnvOptions &  soptions, const Slice &  file_value, bool  for_compaction  )

static

Definition at line 187 of file version_set.cc.

References arg, rocksdb::Status::Corruption(), rocksdb::Slice::data(), DecodeFixed64(), NewErrorIterator(), rocksdb::TableCache::NewIterator(), rocksdb::ReadOptions::prefix, and rocksdb::Slice::size().

Referenced by rocksdb::VersionSet::MakeInputIterator(), and rocksdb::Version::NewConcatenatingIterator().

                                                      {
  TableCache* cache = reinterpret_cast<TableCache*>(arg);
  if (file_value.size() != 16) {
    return NewErrorIterator(
        Status::Corruption("FileReader invoked with unexpected value"));
  } else {
    ReadOptions options_copy;
    if (options.prefix) {
      // suppress prefix filtering since we have already checked the
      // filters once at this point
      options_copy = options;
      options_copy.prefix = nullptr;
    }
    return cache->NewIterator(options.prefix ? options_copy : options,
                              soptions,
                              DecodeFixed64(file_value.data()),
                              DecodeFixed64(file_value.data() + 8),
                              nullptr /* don't need reference to table*/,
                              for_compaction);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::GetInternalKey ( Slice *  input, InternalKey *  dst  )

static

Definition at line 98 of file version_edit.cc.

References rocksdb::InternalKey::DecodeFrom(), and GetLengthPrefixedSlice().

Referenced by rocksdb::VersionEdit::DecodeFrom().

                                                           {
  Slice str;
  if (GetLengthPrefixedSlice(input, &str)) {
    dst->DecodeFrom(str);
    return true;
  } else {
    return false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t rocksdb::GetInternalKeySeqno ( const Slice &  internal_key)

inline

Definition at line 181 of file dbformat.h.

References rocksdb::Slice::data(), DecodeFixed64(), and rocksdb::Slice::size().

Referenced by BuildTable(), and rocksdb::DBImpl::DoCompactionWork().

                                                               {
  const size_t n = internal_key.size();
  assert(n >= 8);
  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
  return num >> 8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* rocksdb::GetLengthPrefixedSlice	(	const char *	p,
		const char *	limit,
		Slice *	result
	)

Definition at line 191 of file coding.cc.

References GetVarint32Ptr().

Referenced by rocksdb::VersionEdit::DecodeFrom(), rocksdb::MemTable::Get(), GetInternalKey(), rocksdb::WriteBatch::Iterate(), rocksdb::MemTableIterator::key(), rocksdb::MemTable::KeyComparator::operator()(), rocksdb::stl_wrappers::Hash::operator()(), TEST(), rocksdb::MemTableRep::UserKey(), and rocksdb::MemTableIterator::value().

                                                  {
  uint32_t len;
  p = GetVarint32Ptr(p, limit, &len);
  if (p == nullptr) return nullptr;
  if (p + len > limit) return nullptr;
  *result = Slice(p, len);
  return p + len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rocksdb::GetLengthPrefixedSlice	(	Slice *	input,
		Slice *	result
	)

Definition at line 201 of file coding.cc.

References rocksdb::Slice::data(), GetVarint32(), rocksdb::Slice::remove_prefix(), and rocksdb::Slice::size().

                                                         {
  uint32_t len;
  if (GetVarint32(input, &len) &&
      input->size() >= len) {
    *result = Slice(input->data(), len);
    input->remove_prefix(len);
    return true;
  } else {
    return false;
  }
}

Here is the call graph for this function:

Slice rocksdb::GetLengthPrefixedSlice

(

const char *

data)

Definition at line 213 of file coding.cc.

References GetVarint32Ptr().

                                               {
  uint32_t len;
  const char* p = data;
  p = GetVarint32Ptr(p, p + 5, &len);  // +5: we assume "p" is not corrupted
  return Slice(p, len);
}

Here is the call graph for this function:

uint64_t rocksdb::GetLogDirSize	(	std::string	dir_path,
		SpecialEnv *	env
	)

Definition at line 3934 of file db_test.cc.

References ripple::f, rocksdb::EnvWrapper::GetChildren(), rocksdb::EnvWrapper::GetFileSize(), kLogFile, and ParseFileName().

Referenced by TEST().

                                                            {
  uint64_t dir_size = 0;
  std::vector<std::string> files;
  env->GetChildren(dir_path, &files);
  for (auto& f : files) {
    uint64_t number;
    FileType type;
    if (ParseFileName(f, &number, &type) && type == kLogFile) {
      std::string const file_path = dir_path + "/" + f;
      uint64_t file_size;
      env->GetFileSize(file_path, &file_size);
      dir_size += file_size;
    }
  }
  return dir_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TableBuilder * rocksdb::GetTableBuilder	(	const Options &	options,
		WritableFile *	file,
		CompressionType	compression_type
	)

Definition at line 29 of file builder.cc.

References rocksdb::Options::table_factory.

Referenced by BuildTable(), and rocksdb::DBImpl::OpenCompactionOutputFile().

                                                                {
  return options.table_factory->GetTableBuilder(options, file,
                                                compression_type);
}

Here is the caller graph for this function:

bool rocksdb::GetVarint32	(	Slice *	input,
		uint32_t *	value
	)

Definition at line 150 of file coding.cc.

References rocksdb::Slice::data(), GetVarint32Ptr(), and rocksdb::Slice::size().

Referenced by rocksdb::VersionEdit::DecodeFrom(), GetLengthPrefixedSlice(), rocksdb::VersionEdit::GetLevel(), and TEST().

                                                {
  const char* p = input->data();
  const char* limit = p + input->size();
  const char* q = GetVarint32Ptr(p, limit, value);
  if (q == nullptr) {
    return false;
  } else {
    *input = Slice(q, limit - q);
    return true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * rocksdb::GetVarint32Ptr ( const char *  p, const char *  limit, uint32_t *  v  )

inline

Definition at line 98 of file coding.h.

References GetVarint32PtrFallback().

Referenced by DecodeEntry(), rocksdb::MemTable::Get(), GetLengthPrefixedSlice(), GetVarint32(), TEST(), and rocksdb::MemTable::Update().

                                                   {
  if (p < limit) {
    uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
    if ((result & 128) == 0) {
      *value = result;
      return p + 1;
    }
  }
  return GetVarint32PtrFallback(p, limit, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * rocksdb::GetVarint32PtrFallback	(	const char *	p,
		const char *	limit,
		uint32_t *	value
	)

Definition at line 131 of file coding.cc.

Referenced by GetVarint32Ptr().

                                                    {
  uint32_t result = 0;
  for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {
    uint32_t byte = *(reinterpret_cast<const unsigned char*>(p));
    p++;
    if (byte & 128) {
      // More bytes are present
      result |= ((byte & 127) << shift);
    } else {
      result |= (byte << shift);
      *value = result;
      return reinterpret_cast<const char*>(p);
    }
  }
  return nullptr;
}

Here is the caller graph for this function:

bool rocksdb::GetVarint64	(	Slice *	input,
		uint64_t *	value
	)

Definition at line 179 of file coding.cc.

References rocksdb::Slice::data(), GetVarint64Ptr(), and rocksdb::Slice::size().

Referenced by rocksdb::BlockHandle::DecodeFrom(), rocksdb::VersionEdit::DecodeFrom(), GetDeletedKeys(), IsSingleVarint(), and rocksdb::BlockBasedTable::ReadProperties().

                                                {
  const char* p = input->data();
  const char* limit = p + input->size();
  const char* q = GetVarint64Ptr(p, limit, value);
  if (q == nullptr) {
    return false;
  } else {
    *input = Slice(q, limit - q);
    return true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * rocksdb::GetVarint64Ptr	(	const char *	p,
		const char *	limit,
		uint64_t *	value
	)

Definition at line 162 of file coding.cc.

Referenced by GetVarint64(), and TEST().

                                                                              {
  uint64_t result = 0;
  for (uint32_t shift = 0; shift <= 63 && p < limit; shift += 7) {
    uint64_t byte = *(reinterpret_cast<const unsigned char*>(p));
    p++;
    if (byte & 128) {
      // More bytes are present
      result |= ((byte & 127) << shift);
    } else {
      result |= (byte << shift);
      *value = result;
      return reinterpret_cast<const char*>(p);
    }
  }
  return nullptr;
}

Here is the caller graph for this function:

rocksdb::has_from_

(

false

)

Referenced by is_input_key_hex_().

Here is the caller graph for this function:

rocksdb::has_to_

(

false

)

Referenced by is_input_key_hex_().

Here is the caller graph for this function:

uint32_t rocksdb::Hash	(	const char *	data,
		size_t	n,
		uint32_t	seed
	)

Definition at line 16 of file hash.cc.

References DecodeFixed32().

Referenced by rocksdb::TestHashFilter::CreateFilter(), rocksdb::ConcurrentTest::HashNumbers(), and rocksdb::TestHashFilter::KeyMayMatch().

                                                         {
  // Similar to murmur hash
  const uint32_t m = 0xc6a4a793;
  const uint32_t r = 24;
  const char* limit = data + n;
  uint32_t h = seed ^ (n * m);

  // Pick up four bytes at a time
  while (data + 4 <= limit) {
    uint32_t w = DecodeFixed32(data);
    data += 4;
    h += w;
    h *= m;
    h ^= (h >> 16);
  }

  // Pick up remaining bytes
  switch (limit - data) {
    case 3:
      h += data[2] << 16;
      // fall through
    case 2:
      h += data[1] << 8;
      // fall through
    case 1:
      h += data[0];
      h *= m;
      h ^= (h >> r);
      break;
  }
  return h;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::IdentityFileName

(

const std::string &

dbname)

Definition at line 130 of file filename.cc.

Referenced by rocksdb::DBImpl::Recover(), SetIdentityFile(), and TEST().

                                                    {
  return dbname + "/IDENTITY";
}

Here is the caller graph for this function:

rocksdb::if

(

params.size()!

= 1)

Definition at line 1359 of file ldb_cmd.cc.

References rocksdb::LDBCommand::exec_state_, and rocksdb::LDBCommandExecuteResult::FAILED().

Referenced by beast::asio::InputParser::Get< UInt32Str >::func(), ripple::Pathfinder::getPaths(), ripple::LedgerConsensusImp::getTransactionTree(), ripple::NetworkOPsImp::getTXMap(), ripple::RippleAddress::humanAccountID(), rocksdb::PosixLogger::Logv(), rocksdb::DBImpl::PurgeObsoleteWALFiles(), ripple::PeerImp::recvGetObjectByHash(), ripple::FeaturesImpl::setJson(), and beast::sysinfo().

                          {
    exec_state_ = LDBCommandExecuteResult::FAILED(
                    "<key> must be specified for the get command");
  } else {

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::if

(

is_key_hex_

)

Definition at line 1366 of file ldb_cmd.cc.

References rocksdb::LDBCommand::HexToString(), and rocksdb::GetCommand::key_.

                   {
    key_ = HexToString(key_);
  }

Here is the call graph for this function:

static std::string rocksdb::IKey ( const std::string &  user_key, uint64_t  seq, ValueType  vt  )

static

Definition at line 16 of file dbformat_test.cc.

References AppendInternalKey().

Referenced by TEST(), and TestKey().

                                      {
  std::string encoded;
  AppendInternalKey(&encoded, ParsedInternalKey(user_key, seq, vt));
  return encoded;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::IncBucketCounts	(	vector< uint64_t > &	bucket_counts,
		int	ttl_start,
		int	time_range,
		int	bucket_size,
		int	timekv,
		int	num_buckets
	)

Definition at line 564 of file ldb_cmd.cc.

Referenced by rocksdb::DBDumperCommand::DoCommand().

                                                                    {
  assert(time_range > 0 && timekv >= ttl_start && bucket_size > 0 &&
    timekv < (ttl_start + time_range) && num_buckets > 1);
  int bucket = (timekv - ttl_start) / bucket_size;
  bucket_counts[bucket]++;
}

Here is the caller graph for this function:

static void rocksdb::Increment ( const Comparator *  cmp, std::string *  key  )

static

Definition at line 76 of file table_test.cc.

References BytewiseComparator(), and reverse_key_comparator.

Referenced by rocksdb::Harness::PickRandomKey().

                                                             {
  if (cmp == BytewiseComparator()) {
    key->push_back('\0');
  } else {
    assert(cmp == &reverse_key_comparator);
    std::string rev = Reverse(*key);
    rev.push_back('\0');
    *key = Reverse(rev);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::InfoLogFileName	(	const std::string &	dbname,
		const std::string &	db_path,
		const std::string &	log_dir
	)

Definition at line 99 of file filename.cc.

References FlattenPath().

Referenced by rocksdb::AutoRollLogger::AutoRollLogger(), and CreateLoggerFromOptions().

                                                        {
  if (log_dir.empty())
    return dbname + "/LOG";

  char flatten_db_path[256];
  FlattenPath(db_path, flatten_db_path, 256);
  return log_dir + "/" + flatten_db_path + "_LOG";
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rocksdb::InitModule ( )

static

Definition at line 77 of file comparator.cc.

References bytewise.

Referenced by BytewiseComparator().

                         {
  bytewise = new BytewiseComparatorImpl;
}

Here is the caller graph for this function:

static void rocksdb::InputSummary ( std::vector< FileMetaData * > &  files, char *  output, int  len  )

static

Definition at line 3114 of file version_set.cc.

Referenced by rocksdb::Compaction::Summary().

             {
  int write = 0;
  for (unsigned int i = 0; i < files.size(); i++) {
    int sz = len - write;
    int ret = snprintf(output + write, sz, "%lu(%lu) ",
        (unsigned long)files.at(i)->number,
        (unsigned long)files.at(i)->file_size);
    if (ret < 0 || ret >= sz)
      break;
    write += ret;
  }
}

Here is the caller graph for this function:

void rocksdb::InstallStackTraceHandler

(

)

Definition at line 98 of file stack_trace.cc.

Referenced by main().

{}

Here is the caller graph for this function:

size_t rocksdb::InternalKeyEncodingLength ( const ParsedInternalKey &  key)

inline

Definition at line 59 of file dbformat.h.

References rocksdb::Slice::size(), and rocksdb::ParsedInternalKey::user_key.

                                                                      {
  return key.user_key.size() + 8;
}

Here is the call graph for this function:

rocksdb::is_input_key_hex_

(

false

)

Definition at line 607 of file ldb_cmd.cc.

References count_delim_(), count_only_(), delim_(), has_from_(), has_to_(), HexToString(), max_keys_(), and print_stats_().

                             {

  has_from_ = ParseStringOption(options, ARG_FROM, &from_);
  has_to_ = ParseStringOption(options, ARG_TO, &to_);

  ParseIntOption(options, ARG_MAX_KEYS, max_keys_, exec_state_);
  map<string, string>::const_iterator itr = options.find(ARG_COUNT_DELIM);
  if (itr != options.end()) {
    delim_ = itr->second;
    count_delim_ = true;
   // fprintf(stdout,"delim = %c\n",delim_[0]);
  } else {
    count_delim_ = IsFlagPresent(flags, ARG_COUNT_DELIM);
    delim_=".";
  }

  print_stats_ = IsFlagPresent(flags, ARG_STATS);
  count_only_ = IsFlagPresent(flags, ARG_COUNT_ONLY);
  is_input_key_hex_ = IsFlagPresent(flags, ARG_INPUT_KEY_HEX);

  if (is_input_key_hex_) {
    if (has_from_) {
      from_ = HexToString(from_);
    }
    if (has_to_) {
      to_ = HexToString(to_);
    }
  }
}

Here is the call graph for this function:

bool rocksdb::IsSingleVarint

(

const std::string &

s)

Definition at line 182 of file env_test.cc.

References GetVarint64(), and rocksdb::Slice::size().

                                        {
  Slice slice(s);

  uint64_t v;
  if (!GetVarint64(&slice, &v)) {
    return false;
  }

  return slice.size() == 0;
}

Here is the call graph for this function:

static Slice rocksdb::Key ( int  i, char *  buffer  )

static

Definition at line 20 of file bloom_test.cc.

                                      {
  memcpy(buffer, &i, sizeof(i));
  return Slice(buffer, sizeof(i));
}

static std::string rocksdb::Key ( long  val)

static

Definition at line 349 of file db_stress.cc.

References PutFixed64().

                               {
  std::string little_endian_key;
  std::string big_endian_key;
  PutFixed64(&little_endian_key, val);
  assert(little_endian_key.size() == sizeof(val));
  big_endian_key.resize(sizeof(val));
  for (int i=0; i<(int)sizeof(val); i++) {
    big_endian_key[i] = little_endian_key[sizeof(val) - 1 - i];
  }
  return big_endian_key;
}

Here is the call graph for this function:

static std::string rocksdb::Key ( int  i)

static

Definition at line 678 of file db_test.cc.

                            {
  char buf[100];
  snprintf(buf, sizeof(buf), "key%06d", i);
  return std::string(buf);
}

static std::string rocksdb::Key ( int  i)

static

Definition at line 743 of file simple_table_db_test.cc.

                            {
  char buf[100];
  snprintf(buf, sizeof(buf), "key_______%06d", i);
  return std::string(buf);
}

std::vector<std::uint64_t> rocksdb::ListLogFiles	(	Env *	env,
		const std::string &	path
	)

Definition at line 3872 of file db_test.cc.

References rocksdb::Env::GetChildren(), kLogFile, and ParseFileName().

Referenced by TEST().

                                                                     {
  std::vector<std::string> files;
  std::vector<uint64_t> log_files;
  env->GetChildren(path, &files);
  uint64_t number;
  FileType type;
  for (size_t i = 0; i < files.size(); ++i) {
    if (ParseFileName(files[i], &number, &type)) {
      if (type == kLogFile) {
        log_files.push_back(number);
      }
    }
  }
  return std::move(log_files);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::LockFileName

(

const std::string &

dbname)

Definition at line 90 of file filename.cc.

Referenced by DestroyDB(), rocksdb::DBImpl::Recover(), and TEST().

                                                {
  return dbname + "/LOCK";
}

Here is the caller graph for this function:

void rocksdb::Log	(	const shared_ptr< Logger > &	info_log,
		const char *	format,
			...
	)

Definition at line 54 of file env.cc.

Referenced by ripple::addTxnSeqField(), ripple::Ledger::assertSane(), rocksdb::DBImpl::BackgroundCallCompaction(), rocksdb::DBImpl::BackgroundCallFlush(), rocksdb::DBImpl::BackgroundCompaction(), rocksdb::DBImpl::BackgroundFlush(), ripple::Transaction::checkSign(), rocksdb::VersionSet::CompactRange(), rocksdb::LogReporter::Corruption(), rocksdb::DBImpl::DBImpl(), rocksdb::DBImplReadOnly::DBImplReadOnly(), rocksdb::DBImpl::DelayLoggingAndReset(), rocksdb::DBImpl::DeleteFile(), rocksdb::DBImpl::DisableFileDeletions(), rocksdb::DBImpl::DoCompactionWork(), ripple::AccountState::dump(), rocksdb::Options::Dump(), rocksdb::DBImpl::EnableFileDeletions(), rocksdb::DBImpl::findEarliestVisibleSnapshot(), rocksdb::BlockBasedTableBuilder::Finish(), rocksdb::DBImpl::FinishCompactionOutputFile(), rocksdb::DBImpl::FlushMemTableToOutputFile(), rocksdb::TtlMergeOperator::FullMerge(), rocksdb::DBImpl::GetLiveFiles(), ripple::Ledger::getSQL(), AutoSocket::handle_autodetect(), rocksdb::LogReporter::Info(), rocksdb::DBImpl::InstallCompactionResults(), rocksdb::MemTableList::InstallMemtableFlushResults(), ripple::SerializedValidation::isValid(), rocksdb::SimpleTableIterator::key(), rocksdb::VersionSet::LogAndApply(), LogMessage(), ripple::logTimedDestroy(), rocksdb::DBImpl::MakeRoomForWrite(), rocksdb::VersionSet::ManifestContains(), rocksdb::DBImpl::MaybeDumpStats(), rocksdb::DBImpl::MaybeIgnoreError(), rocksdb::BlockBasedTable::Open(), ripple::STObject::operator==(), rocksdb::TtlMergeOperator::PartialMerge(), rocksdb::VersionSet::PickCompactionUniversal(), rocksdb::VersionSet::PickCompactionUniversalReadAmp(), rocksdb::VersionSet::PickCompactionUniversalSizeAmp(), rocksdb::DBImpl::PrintStatistics(), rocksdb::DBImpl::PurgeObsoleteFiles(), rocksdb::DBImpl::PurgeObsoleteWALFiles(), rocksdb::DBImpl::ReadFirstLine(), rocksdb::BlockBasedTable::ReadMetaBlock(), rocksdb::BlockBasedTable::ReadProperties(), rocksdb::VersionSet::Recover(), rocksdb::DBImpl::RecoverLogFile(), rocksdb::DBImpl::ReFitLevel(), AutoSocket::rfc2818_verify(), SanitizeOptions(), ripple::schemaHas(), ripple::SerializedTransaction::SerializedTransaction(), ripple::SerializedValidation::SerializedValidation(), ripple::LogSink::setLogFile(), ripple::NetworkOPsImp::setMode(), rocksdb::VersionSet::SetupOtherInputs(), ripple::Transaction::sharedTransaction(), ripple::Transaction::sign(), rocksdb::DBImpl::TEST_CompactRange(), ripple::ApplicationImp::updateTables(), rocksdb::VersionSet::VerifyCompactionFileConsistency(), ripple::Ledger::walkLedger(), ripple::Ledger::writeBack(), rocksdb::DBImpl::WriteLevel0Table(), and rocksdb::DBImpl::WriteLevel0TableForRecovery().

                                                                      {
  if (info_log) {
    va_list ap;
    va_start(ap, format);
    info_log->Logv(format, ap);
    va_end(ap);
  }
}

void rocksdb::Log	(	Logger *	info_log,
		const char *	format,
			...
	)

Definition at line 39 of file env.cc.

References rocksdb::Logger::Logv().

                                                    {
  if (info_log) {
    va_list ap;
    va_start(ap, format);
    info_log->Logv(format, ap);
    va_end(ap);
  }
}

Here is the call graph for this function:

std::string rocksdb::LogFileName	(	const std::string &	name,
		uint64_t	number
	)

Definition at line 60 of file filename.cc.

References MakeFileName().

Referenced by rocksdb::DBImpl::AppendSortedWalsOfType(), rocksdb::DBImpl::CheckWalFileExistsAndEmpty(), rocksdb::DBImpl::MakeRoomForWrite(), rocksdb::DB::Open(), rocksdb::TransactionLogIteratorImpl::OpenLogFile(), rocksdb::LogFileImpl::PathName(), rocksdb::DBImpl::PurgeObsoleteFiles(), rocksdb::DBImpl::ReadFirstRecord(), rocksdb::DBImpl::RecoverLogFile(), and TEST().

                                                              {
  assert(number > 0);
  return MakeFileName(name, number, "log");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::LogFlush

(

const shared_ptr< Logger > &

info_log)

Definition at line 48 of file env.cc.

Referenced by rocksdb::DBImpl::BackgroundCallCompaction(), rocksdb::DBImpl::BackgroundCallFlush(), rocksdb::DBImpl::CompactRange(), rocksdb::DBImpl::DBImpl(), rocksdb::DBImpl::DeleteFile(), rocksdb::DBImpl::DoCompactionWork(), rocksdb::DBImpl::EnableFileDeletions(), rocksdb::DBImpl::GetImpl(), rocksdb::VersionSet::LogAndApply(), rocksdb::DBImpl::MultiGet(), rocksdb::DBImpl::NewInternalIterator(), rocksdb::DBImpl::OpenCompactionOutputFile(), rocksdb::DBImpl::PurgeObsoleteFiles(), rocksdb::DBImpl::TEST_Destroy_DBImpl(), rocksdb::DBImpl::Write(), rocksdb::DBImpl::WriteLevel0Table(), rocksdb::DBImpl::WriteLevel0TableForRecovery(), and rocksdb::DBImpl::~DBImpl().

                                                  {
  if (info_log) {
    info_log->Flush();
  }
}

Here is the caller graph for this function:

void rocksdb::LogFlush

(

Logger *

info_log)

Definition at line 33 of file env.cc.

References rocksdb::Logger::Flush().

                                {
  if (info_log) {
    info_log->Flush();
  }
}

Here is the call graph for this function:

void rocksdb::LogMessage	(	Logger *	logger,
		const char *	message
	)

Definition at line 52 of file auto_roll_logger_test.cc.

References Log().

Referenced by rocksdb::AutoRollLoggerTest::RollLogFileBySizeTest(), rocksdb::AutoRollLoggerTest::RollLogFileByTimeTest(), and TEST().

                                                     {
  Log(logger, "%s", message);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::MakeBuilder	(	const Options &	options,
		std::unique_ptr< FakeWritableFile > *	writable,
		std::unique_ptr< TableBuilder > *	builder
	)

Definition at line 86 of file table_properties_collector_test.cc.

References rocksdb::Options::compression, and rocksdb::Options::table_factory.

Referenced by TEST().

                                          {
  writable->reset(new FakeWritableFile);
  builder->reset(
      options.table_factory->GetTableBuilder(options, writable->get(),
                                             options.compression));
}

Here is the caller graph for this function:

static std::string rocksdb::MakeFileName ( const std::string &  name, uint64_t  number, const char *  suffix  )

static

Definition at line 51 of file filename.cc.

Referenced by ArchivedLogFileName(), LogFileName(), TableFileName(), and TempFileName().

                                                    {
  char buf[100];
  snprintf(buf, sizeof(buf), "/%06llu.%s",
           static_cast<unsigned long long>(number),
           suffix);
  return name + buf;
}

Here is the caller graph for this function:

static std::string rocksdb::MakeKey ( int  i, int  j, bool  through_db  )

static

Definition at line 22 of file table_reader_bench.cc.

References rocksdb::InternalKey::Encode(), kTypeValue, and rocksdb::Slice::ToString().

                                                        {
  char buf[100];
  snprintf(buf, sizeof(buf), "%04d__key___%04d", i, j);
  if (through_db) {
    return std::string(buf);
  }
  // If we directly query table, which operates on internal keys
  // instead of user keys, we need to add 8 bytes of internal
  // information (row type etc) to user key to make an internal
  // key.
  InternalKey key(std::string(buf), 0, ValueType::kTypeValue);
  return key.Encode().ToString();
}

Here is the call graph for this function:

std::string rocksdb::MakeKey

(

unsigned int

num)

Definition at line 4857 of file db_test.cc.

Referenced by BM_LogAndApply(), and TableReaderBenchmark().

                                    {
  char buf[30];
  snprintf(buf, sizeof(buf), "%016u", num);
  return std::string(buf);
}

Here is the caller graph for this function:

void rocksdb::MakeUpper

(

std::string *const

s)

THE manual REDIS TEST begins here THIS WILL ONLY OCCUR IF YOU RUN: ./redis_test -m

Definition at line 741 of file redis_lists_test.cc.

Referenced by manual_redis_test().

                                   {
  int len = s->length();
  for(int i=0; i<len; ++i) {
    (*s)[i] = toupper((*s)[i]); // C-version defined in <ctype.h>
  }
}

Here is the caller graph for this function:

int rocksdb::manual_redis_test

(

bool

destructive)

Allows the user to enter in REDIS commands into the command-line. This is useful for manual / interacticve testing / debugging. Use destructive=true to clean the database before use. Use destructive=false to remember the previous state (i.e.: persistent) Should be called from main function.

Definition at line 753 of file redis_lists_test.cc.

References rocksdb::RedisLists::Index(), rocksdb::RedisLists::InsertAfter(), rocksdb::RedisLists::InsertBefore(), rocksdb::RedisListsTest::kDefaultDbName, rocksdb::RedisLists::Length(), MakeUpper(), rocksdb::RedisListsTest::options, rocksdb::RedisLists::PopLeft(), rocksdb::RedisLists::PopRight(), rocksdb::RedisLists::Print(), rocksdb::RedisLists::PushLeft(), rocksdb::RedisLists::PushRight(), rocksdb::RedisLists::Range(), rocksdb::RedisLists::Remove(), rocksdb::RedisLists::Set(), and rocksdb::RedisLists::Trim().

Referenced by main().

                                       {
  RedisLists redis(RedisListsTest::kDefaultDbName,
                   RedisListsTest::options,
                   destructive);

  // TODO: Right now, please use spaces to separate each word.
  //  In actual redis, you can use quotes to specify compound values
  //  Example: RPUSH mylist "this is a compound value"

  std::string command;
  while(true) {
    cin >> command;
    MakeUpper(&command);

    if (command == "LINSERT") {
      std::string k, t, p, v;
      cin >> k >> t >> p >> v;
      MakeUpper(&t);
      if (t=="BEFORE") {
        std::cout << redis.InsertBefore(k, p, v) << std::endl;
      } else if (t=="AFTER") {
        std::cout << redis.InsertAfter(k, p, v) << std::endl;
      }
    } else if (command == "LPUSH") {
      std::string k, v;
      std::cin >> k >> v;
      redis.PushLeft(k, v);
    } else if (command == "RPUSH") {
      std::string k, v;
      std::cin >> k >> v;
      redis.PushRight(k, v);
    } else if (command == "LPOP") {
      std::string k;
      std::cin >> k;
      string res;
      redis.PopLeft(k, &res);
      std::cout << res << std::endl;
    } else if (command == "RPOP") {
      std::string k;
      std::cin >> k;
      string res;
      redis.PopRight(k, &res);
      std::cout << res << std::endl;
    } else if (command == "LREM") {
      std::string k;
      int amt;
      std::string v;

      std::cin >> k >> amt >> v;
      std::cout << redis.Remove(k, amt, v) << std::endl;
    } else if (command == "LLEN") {
      std::string k;
      std::cin >> k;
      std::cout << redis.Length(k) << std::endl;
    } else if (command == "LRANGE") {
      std::string k;
      int i, j;
      std::cin >> k >> i >> j;
      std::vector<std::string> res = redis.Range(k, i, j);
      for (auto it = res.begin(); it != res.end(); ++it) {
        std::cout << " " << (*it);
      }
      std::cout << std::endl;
    } else if (command == "LTRIM") {
      std::string k;
      int i, j;
      std::cin >> k >> i >> j;
      redis.Trim(k, i, j);
    } else if (command == "LSET") {
      std::string k;
      int idx;
      std::string v;
      cin >> k >> idx >> v;
      redis.Set(k, idx, v);
    } else if (command == "LINDEX") {
      std::string k;
      int idx;
      std::cin >> k >> idx;
      string res;
      redis.Index(k, idx, &res);
      std::cout << res << std::endl;
    } else if (command == "PRINT") {      // Added by Deon
      std::string k;
      cin >> k;
      redis.Print(k);
    } else if (command == "QUIT") {
      return 0;
    } else {
      std::cout << "unknown command: " << command << std::endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rocksdb::MarkKeyMayExist ( void *  arg)

static

Definition at line 302 of file version_set.cc.

References arg.

Referenced by rocksdb::Version::Get().

                                       {
  Saver* s = reinterpret_cast<Saver*>(arg);
  s->state = kFound;
  if (s->value_found != nullptr) {
    *(s->value_found) = false;
  }
}

Here is the caller graph for this function:

rocksdb::max_keys_

(

-

1)

Referenced by is_input_key_hex_(), and print_stats_().

Here is the caller graph for this function:

rocksdb::max_keys_scanned_

(

-

1)

Definition at line 1503 of file ldb_cmd.cc.

References end_key_specified_(), rocksdb::LDBCommandExecuteResult::FAILED(), HexToString(), and start_key_specified_().

                          {

  map<string, string>::const_iterator itr = options.find(ARG_FROM);
  if (itr != options.end()) {
    start_key_ = itr->second;
    if (is_key_hex_) {
      start_key_ = HexToString(start_key_);
    }
    start_key_specified_ = true;
  }
  itr = options.find(ARG_TO);
  if (itr != options.end()) {
    end_key_ = itr->second;
    if (is_key_hex_) {
      end_key_ = HexToString(end_key_);
    }
    end_key_specified_ = true;
  }

  itr = options.find(ARG_MAX_KEYS);
  if (itr != options.end()) {
    try {
      max_keys_scanned_ = stoi(itr->second);
    } catch(const invalid_argument&) {
      exec_state_ = LDBCommandExecuteResult::FAILED(ARG_MAX_KEYS +
                        " has an invalid value");
    } catch(const out_of_range&) {
      exec_state_ = LDBCommandExecuteResult::FAILED(ARG_MAX_KEYS +
                        " has a value out-of-range");
    }
  }
}

Here is the call graph for this function:

rocksdb::maxBucketValue_

(

bucketValues_.

back())

std::string rocksdb::MetaDatabaseName	(	const std::string &	dbname,
		uint64_t	number
	)

Definition at line 123 of file filename.cc.

Referenced by TEST().

                                                                     {
  char buf[100];
  snprintf(buf, sizeof(buf), "/METADB-%llu",
           static_cast<unsigned long long>(number));
  return dbname + buf;
}

Here is the caller graph for this function:

rocksdb::minBucketValue_

(

bucketValues_.

front())

Definition at line 39 of file histogram.cc.

                                         {
  for (size_t i =0; i < bucketValues_.size(); ++i) {
    valueIndexMap_[bucketValues_[i]] = i;
  }
}

void rocksdb::MinLevelHelper	(	DBTest *	self,
		Options &	options
	)

Definition at line 2342 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::level0_file_num_compaction_trigger, and RandomString().

Referenced by TEST().

                                                    {
  Random rnd(301);

  for (int num = 0;
    num < options.level0_file_num_compaction_trigger - 1;
    num++)
  {
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      values.push_back(RandomString(&rnd, 10000));
      ASSERT_OK(self->Put(Key(i), values[i]));
    }
    self->dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(self->NumTableFilesAtLevel(0), num + 1);
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
    values.push_back(RandomString(&rnd, 10000));
    ASSERT_OK(self->Put(Key(i), values[i]));
  }
  self->dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(self->NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(self->NumTableFilesAtLevel(1), 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rocksdb::MinLevelToCompress	(	CompressionType &	type,
		Options &	options,
		int	wbits,
		int	lev,
		int	strategy
	)

Definition at line 2372 of file db_test.cc.

References BZip2CompressionSupported(), rocksdb::Options::compression_per_level, rocksdb::Options::create_if_missing, kBZip2Compression, kNoCompression, kSnappyCompression, kZlibCompression, rocksdb::Options::level0_file_num_compaction_trigger, rocksdb::Options::max_mem_compaction_level, rocksdb::Options::num_levels, SnappyCompressionSupported(), rocksdb::Options::write_buffer_size, and ZlibCompressionSupported().

Referenced by TEST().

                                               {
  fprintf(stderr, "Test with compression options : window_bits = %d, level =  %d, strategy = %d}\n", wbits, lev, strategy);
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
  options.create_if_missing = true;

  if (SnappyCompressionSupported(CompressionOptions(wbits, lev, strategy))) {
    type = kSnappyCompression;
    fprintf(stderr, "using snappy\n");
  } else if (ZlibCompressionSupported(
               CompressionOptions(wbits, lev, strategy))) {
    type = kZlibCompression;
    fprintf(stderr, "using zlib\n");
  } else if (BZip2CompressionSupported(
               CompressionOptions(wbits, lev, strategy))) {
    type = kBZip2Compression;
    fprintf(stderr, "using bzip2\n");
  } else {
    fprintf(stderr, "skipping test, compression disabled\n");
    return false;
  }
  options.compression_per_level.resize(options.num_levels);

  // do not compress L0
  for (int i = 0; i < 1; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 1; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::new_compaction_style_

(

-

1)

Definition at line 1107 of file ldb_cmd.cc.

References rocksdb::LDBCommandExecuteResult::FAILED(), kCompactionStyleLevel, kCompactionStyleUniversal, and old_compaction_style_().

                              {

  ParseIntOption(option_map_, ARG_OLD_COMPACTION_STYLE, old_compaction_style_,
    exec_state_);
  if (old_compaction_style_ != kCompactionStyleLevel &&
     old_compaction_style_ != kCompactionStyleUniversal) {
    exec_state_ = LDBCommandExecuteResult::FAILED(
      "Use --" + ARG_OLD_COMPACTION_STYLE + " to specify old compaction " +
      "style. Check ldb help for proper compaction style value.\n");
    return;
  }

  ParseIntOption(option_map_, ARG_NEW_COMPACTION_STYLE, new_compaction_style_,
    exec_state_);
  if (new_compaction_style_ != kCompactionStyleLevel &&
     new_compaction_style_ != kCompactionStyleUniversal) {
    exec_state_ = LDBCommandExecuteResult::FAILED(
      "Use --" + ARG_NEW_COMPACTION_STYLE + " to specify new compaction " +
      "style. Check ldb help for proper compaction style value.\n");
    return;
  }

  if (new_compaction_style_ == old_compaction_style_) {
    exec_state_ = LDBCommandExecuteResult::FAILED(
      "Old compaction style is the same as new compaction style. "
      "Nothing to do.\n");
    return;
  }

  if (old_compaction_style_ == kCompactionStyleUniversal &&
      new_compaction_style_ == kCompactionStyleLevel) {
    exec_state_ = LDBCommandExecuteResult::FAILED(
      "Convert from universal compaction to level compaction. "
      "Nothing to do.\n");
    return;
  }
}

Here is the call graph for this function:

rocksdb::new_levels_

(

-

1)

Referenced by print_old_levels_().

Here is the caller graph for this function:

const FilterPolicy * rocksdb::NewBloomFilterPolicy

(

int

bits_per_key)

Definition at line 107 of file bloom.cc.

Referenced by rocksdb::DBTest::DBTest(), leveldb_filterpolicy_create_bloom(), ripple::NodeStore::LevelDBBackend::LevelDBBackend(), rocksdb::LDBCommand::PrepareOptionsForOpenDB(), and TEST().

                                                           {
  return new BloomFilterPolicy(bits_per_key);
}

Here is the caller graph for this function:

Iterator * rocksdb::NewDBIterator	(	const std::string *	dbname,
		Env *	env,
		const Options &	options,
		const Comparator *	user_key_comparator,
		Iterator *	internal_iter,
		const SequenceNumber &	sequence
	)

Definition at line 470 of file db_iter.cc.

Referenced by rocksdb::DBImplReadOnly::NewIterator(), and rocksdb::DBImpl::NewIterator().

                                    {
  return new DBIter(dbname, env, options, user_key_comparator,
                    internal_iter, sequence);
}

Here is the caller graph for this function:

Iterator * rocksdb::NewEmptyIterator

(

)

Definition at line 64 of file iterator.cc.

References rocksdb::Status::OK().

Referenced by rocksdb::Version::NewConcatenatingIterator(), rocksdb::Block::NewIterator(), rocksdb::BlockBasedTable::NewIterator(), and NewMergingIterator().

                             {
  return new EmptyIterator(Status::OK());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Iterator * rocksdb::NewErrorIterator

(

const Status &

status)

Definition at line 68 of file iterator.cc.

Referenced by rocksdb::BlockBasedTable::BlockReader(), GetFileIterator(), rocksdb::BlockBasedTable::IndexBlockReader(), rocksdb::Block::NewIterator(), and rocksdb::TableCache::NewIterator().

                                                 {
  return new EmptyIterator(status);
}

Here is the caller graph for this function:

static bool rocksdb::NewestFirst ( FileMetaData *  a, FileMetaData *  b  )

static

Definition at line 391 of file version_set.cc.

References rocksdb::FileMetaData::number.

Referenced by rocksdb::Version::Get().

                                                          {
  return a->number > b->number;
}

Here is the caller graph for this function:

static bool rocksdb::NewestFirstBySeqNo ( FileMetaData *  a, FileMetaData *  b  )

static

Definition at line 394 of file version_set.cc.

References rocksdb::FileMetaData::largest_seqno, and rocksdb::FileMetaData::smallest_seqno.

Referenced by rocksdb::Version::Get().

                                                                 {
  if (a->smallest_seqno > b->smallest_seqno) {
    assert(a->largest_seqno > b->largest_seqno);
    return true;
  }
  assert(a->largest_seqno <= b->largest_seqno);
  return false;
}

Here is the caller graph for this function:

const SliceTransform * rocksdb::NewFixedPrefixTransform

(

size_t

prefix_len)

Definition at line 65 of file slice.cc.

Referenced by rocksdb::DBTest::CurrentOptions(), main(), rocksdb::Benchmark::Open(), rocksdb::StressTest::Open(), OpenDb(), rocksdb::PrefixTest::OpenDb(), and TEST().

                                                                 {
  return new FixedPrefixTransform(prefix_len);
}

Here is the caller graph for this function:

MemTableRepFactory * rocksdb::NewHashSkipListRepFactory	(	const SliceTransform *	transform,
		size_t	bucket_count = 1000000
	)

Definition at line 325 of file hash_skiplist_rep.cc.

Referenced by rocksdb::PrefixTest::OpenDb(), and TEST().

                                                          {
  return new HashSkipListRepFactory(transform, bucket_count);
}

Here is the caller graph for this function:

shared_ptr< Cache > rocksdb::NewLRUCache

(

size_t

capacity)

Definition at line 414 of file cache.cc.

Referenced by rocksdb::CorruptionTest::CorruptionTest(), rocksdb::DBTest::CurrentOptions(), leveldb_cache_create_lru(), ripple::NodeStore::LevelDBBackend::LevelDBBackend(), ripple::NodeStore::LevelDBFactory::LevelDBFactory(), NewLRUCache(), SanitizeOptions(), and TEST().

                                               {
  return NewLRUCache(capacity, kNumShardBits);
}

Here is the caller graph for this function:

shared_ptr< Cache > rocksdb::NewLRUCache	(	size_t	capacity,
		int	numShardBits
	)

Definition at line 418 of file cache.cc.

References NewLRUCache().

                                                                 {
  return NewLRUCache(capacity, numShardBits, kRemoveScanCountLimit);
}

Here is the call graph for this function:

shared_ptr< Cache > rocksdb::NewLRUCache	(	size_t	capacity,
		int	numShardBits,
		int	removeScanCountLimit
	)

Definition at line 422 of file cache.cc.

References numShardBits.

                                                        {
  if (numShardBits >= 20) {
    return nullptr;  // the cache cannot be sharded into too many fine pieces
  }
  return std::make_shared<ShardedLRUCache>(capacity,
                                           numShardBits,
                                           removeScanCountLimit);
}

MaxIterHeap rocksdb::NewMaxIterHeap

(

const Comparator *

comparator)

Definition at line 55 of file iter_heap.h.

                                                         {
  return MaxIterHeap(MaxIteratorComparator(comparator));
}

Env * rocksdb::NewMemEnv

(

Env *

base_env)

Definition at line 382 of file memenv.cc.

                              {
  return new InMemoryEnv(base_env);
}

Iterator * rocksdb::NewMergingIterator	(	const Comparator *	cmp,
		Iterator **	list,
		int	n
	)

Definition at line 217 of file merger.cc.

References NewEmptyIterator().

Referenced by rocksdb::VersionSet::MakeInputIterator(), rocksdb::DBImpl::NewInternalIterator(), and rocksdb::DBImpl::WriteLevel0Table().

                                                                            {
  assert(n >= 0);
  if (n == 0) {
    return NewEmptyIterator();
  } else if (n == 1) {
    return list[0];
  } else {
    return new MergingIterator(cmp, list, n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

MinIterHeap rocksdb::NewMinIterHeap

(

const Comparator *

comparator)

Definition at line 60 of file iter_heap.h.

                                                         {
  return MinIterHeap(MinIteratorComparator(comparator));
}

const SliceTransform * rocksdb::NewNoopTransform

(

)

Definition at line 69 of file slice.cc.

                                         {
  return new NoopTransform;
}

Iterator* rocksdb::NewTwoLevelIterator	(	Iterator *	index_iter,
		Iterator *(*)(void *arg, const ReadOptions &options, const EnvOptions &soptions, const Slice &index_value, bool for_compaction)	block_function,
		void *	arg,
		const ReadOptions &	options,
		const EnvOptions &	soptions,
		bool	for_compaction = false
	)

Iterator* rocksdb::NewTwoLevelIterator	(	Iterator *	index_iter,
		BlockFunction	block_function,
		void *	arg,
		const ReadOptions &	options,
		const EnvOptions &	soptions,
		bool	for_compaction
	)

Definition at line 194 of file two_level_iterator.cc.

Referenced by rocksdb::VersionSet::MakeInputIterator(), rocksdb::Version::NewConcatenatingIterator(), and rocksdb::BlockBasedTable::NewIterator().

                         {
  return new TwoLevelIterator(index_iter, block_function, arg,
                              options, soptions, for_compaction);
}

Here is the caller graph for this function:

static int rocksdb::NextLength ( int  length)

static

Definition at line 106 of file bloom_test.cc.

Referenced by TEST().

                                  {
  if (length < 10) {
    length += 1;
  } else if (length < 100) {
    length += 10;
  } else if (length < 1000) {
    length += 100;
  } else {
    length += 1000;
  }
  return length;
}

Here is the caller graph for this function:

rocksdb::null_from_

(

true

)

Referenced by null_to_(), and print_stats_().

Here is the caller graph for this function:

rocksdb::null_to_

(

true

)

Definition at line 338 of file ldb_cmd.cc.

References HexToString(), and null_from_().

Referenced by print_stats_().

                                     {

  map<string, string>::const_iterator itr = options.find(ARG_FROM);
  if (itr != options.end()) {
    null_from_ = false;
    from_ = itr->second;
  }

  itr = options.find(ARG_TO);
  if (itr != options.end()) {
    null_to_ = false;
    to_ = itr->second;
  }

  if (is_key_hex_) {
    if (!null_from_) {
      from_ = HexToString(from_);
    }
    if (!null_to_) {
      to_ = HexToString(to_);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::NumberToString

(

uint64_t

num)

Definition at line 41 of file logging.cc.

References AppendNumberTo().

Referenced by rocksdb::ChangeCompactionStyleCommand::DoCommand(), rocksdb::ReduceLevelTest::FilesOnLevel(), rocksdb::DBTest::NumTableFilesAtLevel(), rocksdb::SimpleTableDBTest::NumTableFilesAtLevel(), PrintContents(), rocksdb::StressTest::PrintEnv(), and TEST().

                                       {
  std::string r;
  AppendNumberTo(&r, num);
  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::old_compaction_style_

(

-

1)

Referenced by new_compaction_style_().

Here is the caller graph for this function:

rocksdb::old_levels_

(

1<<

16)

std::string rocksdb::OldInfoLogFileName	(	const std::string &	dbname,
		uint64_t	ts,
		const std::string &	db_path,
		const std::string &	log_dir
	)

Definition at line 110 of file filename.cc.

References FlattenPath().

Referenced by CreateLoggerFromOptions(), and rocksdb::AutoRollLogger::RollLogFile().

                                                        {
  char buf[50];
  snprintf(buf, sizeof(buf), "%llu", static_cast<unsigned long long>(ts));

  if (log_dir.empty())
    return dbname + "/LOG.old." + buf;

  char flatten_db_path[256];
  FlattenPath(db_path, flatten_db_path, 256);
  return log_dir + "/" + flatten_db_path + "_LOG.old." + buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rocksdb::OldLogFileCount

(

const string &

dir)

Definition at line 238 of file auto_roll_logger_test.cc.

References kInfoLogFile, and ParseFileName().

                                       {
  std::vector<std::string> files;
  Env::Default()->GetChildren(dir, &files);
  int log_file_count = 0;

  for (std::vector<std::string>::iterator it = files.begin();
       it != files.end(); ++it) {
    uint64_t create_time;
    FileType type;
    if (!ParseFileName(*it, &create_time, &type)) {
      continue;
    }
    if (type == kInfoLogFile && create_time > 0) {
      ++log_file_count;
    }
  }

  return log_file_count;
}

Here is the call graph for this function:

std::shared_ptr<DB> rocksdb::OpenDb

(

)

Definition at line 30 of file perf_context_test.cc.

References ASSERT_OK, rocksdb::Options::create_if_missing, db, FLAGS_max_write_buffer_number, FLAGS_min_write_buffer_number_to_merge, FLAGS_use_set_based_memetable, FLAGS_write_buffer_size, kDbName, rocksdb::Options::max_write_buffer_number, rocksdb::Options::memtable_factory, rocksdb::Options::min_write_buffer_number_to_merge, NewFixedPrefixTransform(), rocksdb::DB::Open(), and rocksdb::Options::write_buffer_size.

Referenced by ProfileKeyComparison(), rocksdb::StringAppendOperatorTest::SetOpenDbFunction(), and TEST().

                           {
    DB* db;
    Options options;
    options.create_if_missing = true;
    options.write_buffer_size = FLAGS_write_buffer_size;
    options.max_write_buffer_number = FLAGS_max_write_buffer_number;
    options.min_write_buffer_number_to_merge =
      FLAGS_min_write_buffer_number_to_merge;

    if (FLAGS_use_set_based_memetable) {
      auto prefix_extractor = rocksdb::NewFixedPrefixTransform(0);
      options.memtable_factory =
        std::make_shared<rocksdb::PrefixHashRepFactory>(prefix_extractor);
    }

    Status s = DB::Open(options, kDbName,  &db);
    ASSERT_OK(s);
    return std::shared_ptr<DB>(db);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<DB> rocksdb::OpenNormalDb

(

char

delim_char)

Definition at line 29 of file stringappend_test.cc.

References ASSERT_OK, rocksdb::Options::create_if_missing, db, kDbName, rocksdb::Options::merge_operator, and rocksdb::DB::Open().

Referenced by main().

                                                {
  DB* db;
  Options options;
  options.create_if_missing = true;
  options.merge_operator.reset(new StringAppendOperator(delim_char));
  ASSERT_OK(DB::Open(options, kDbName,  &db));
  return std::shared_ptr<DB>(db);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::OpenTable	(	const Options &	options,
		const std::string &	contents,
		std::unique_ptr< TableReader > *	table_reader
	)

Definition at line 96 of file table_properties_collector_test.cc.

References ASSERT_OK, and rocksdb::Options::table_factory.

Referenced by TEST().

                                              {

  std::unique_ptr<RandomAccessFile> file(new FakeRandomeAccessFile(contents));
  auto s = options.table_factory->GetTableReader(
      options,
      EnvOptions(),
      std::move(file),
      contents.size(),
      table_reader
  );
  ASSERT_OK(s);
}

Here is the caller graph for this function:

std::shared_ptr<DB> rocksdb::OpenTtlDb

(

char

delim_char)

Definition at line 39 of file stringappend_test.cc.

References ASSERT_OK, rocksdb::Options::create_if_missing, db, kDbName, and rocksdb::Options::merge_operator.

Referenced by main().

                                             {
  StackableDB* db;
  Options options;
  options.create_if_missing = true;
  options.merge_operator.reset(new StringAppendTESTOperator(delim_char));
  Status s;
  db = new DBWithTTL(123456, options, kDbName, s, false);
  ASSERT_OK(s);
  return std::shared_ptr<DB>(db);
}

Here is the caller graph for this function:

bool rocksdb::operator!= ( const Slice &  x, const Slice &  y  )

inline

Definition at line 120 of file slice.h.

                                                       {
  return !(x == y);
}

bool rocksdb::operator== ( const Slice &  x, const Slice &  y  )

inline

Definition at line 115 of file slice.h.

References rocksdb::Slice::data(), and rocksdb::Slice::size().

                                                       {
  return ((x.size() == y.size()) &&
          (memcmp(x.data(), y.data(), x.size()) == 0));
}

Here is the call graph for this function:

static uint64_t rocksdb::PackSequenceAndType ( uint64_t  seq, ValueType  t  )

static

Definition at line 18 of file dbformat.cc.

References kMaxSequenceNumber, and kValueTypeForSeek.

Referenced by AppendInternalKey(), rocksdb::InternalKeyComparator::FindShortestSeparator(), rocksdb::InternalKeyComparator::FindShortSuccessor(), and rocksdb::LookupKey::LookupKey().

                                                               {
  assert(seq <= kMaxSequenceNumber);
  assert(t <= kValueTypeForSeek);
  return (seq << 8) | t;
}

Here is the caller graph for this function:

bool rocksdb::ParseFileName	(	const std::string &	fname,
		uint64_t *	number,
		FileType *	type,
		WalFileType *	log_type
	)

Definition at line 144 of file filename.cc.

References ARCHIVAL_DIR, ConsumeDecimalNumber(), rocksdb::Slice::empty(), kAliveLogFile, kArchivedLogFile, kCurrentFile, kDBLockFile, kDescriptorFile, kIdentityFile, kInfoLogFile, kLogFile, kMetaDatabase, kTableFile, kTempFile, rocksdb::Slice::remove_prefix(), rocksdb::Slice::size(), and rocksdb::Slice::starts_with().

Referenced by rocksdb::DBImpl::AppendSortedWalsOfType(), rocksdb::DeleteFileTest::CheckFileTypeCounts(), rocksdb::CorruptionTest::Corrupt(), rocksdb::DBImpl::DeleteFile(), DestroyDB(), GetLogDirSize(), ListLogFiles(), OldLogFileCount(), rocksdb::DBImpl::PurgeObsoleteFiles(), rocksdb::DBImpl::PurgeObsoleteWALFiles(), rocksdb::DBImpl::Recover(), and TEST().

                                          {
  Slice rest(fname);
  if (fname.length() > 1 && fname[0] == '/') {
    rest.remove_prefix(1);
  }
  if (rest == "IDENTITY") {
    *number = 0;
    *type = kIdentityFile;
  } else if (rest == "CURRENT") {
    *number = 0;
    *type = kCurrentFile;
  } else if (rest == "LOCK") {
    *number = 0;
    *type = kDBLockFile;
  } else if (rest == "LOG" || rest == "LOG.old") {
    *number = 0;
    *type = kInfoLogFile;
  } else if (rest.starts_with("LOG.old.")) {
    uint64_t ts_suffix;
    // sizeof also counts the trailing '\0'.
    rest.remove_prefix(sizeof("LOG.old.") - 1);
    if (!ConsumeDecimalNumber(&rest, &ts_suffix)) {
      return false;
    }
    *number = ts_suffix;
    *type = kInfoLogFile;
  } else if (rest.starts_with("MANIFEST-")) {
    rest.remove_prefix(strlen("MANIFEST-"));
    uint64_t num;
    if (!ConsumeDecimalNumber(&rest, &num)) {
      return false;
    }
    if (!rest.empty()) {
      return false;
    }
    *type = kDescriptorFile;
    *number = num;
  } else if (rest.starts_with("METADB-")) {
    rest.remove_prefix(strlen("METADB-"));
    uint64_t num;
    if (!ConsumeDecimalNumber(&rest, &num)) {
      return false;
    }
    if (!rest.empty()) {
      return false;
    }
    *type = kMetaDatabase;
    *number = num;
  } else {
    // Avoid strtoull() to keep filename format independent of the
    // current locale
    bool archive_dir_found = false;
    if (rest.starts_with(ARCHIVAL_DIR)) {
      if (rest.size() <= ARCHIVAL_DIR.size()) {
        return false;
      }
      rest.remove_prefix(ARCHIVAL_DIR.size() + 1); // Add 1 to remove / also
      if (log_type) {
        *log_type = kArchivedLogFile;
      }
      archive_dir_found = true;
    }
    uint64_t num;
    if (!ConsumeDecimalNumber(&rest, &num)) {
      return false;
    }
    Slice suffix = rest;
    if (suffix == Slice(".log")) {
      *type = kLogFile;
      if (log_type && !archive_dir_found) {
        *log_type = kAliveLogFile;
      }
    } else if (archive_dir_found) {
      return false; // Archive dir can contain only log files
    } else if (suffix == Slice(".sst")) {
      *type = kTableFile;
    } else if (suffix == Slice(".dbtmp")) {
      *type = kTempFile;
    } else {
      return false;
    }
    *number = num;
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rocksdb::ParseInternalKey ( const Slice &  internal_key, ParsedInternalKey *  result  )

inline

Definition at line 158 of file dbformat.h.

References rocksdb::Slice::data(), DecodeFixed64(), kValueTypeForSeek, rocksdb::ParsedInternalKey::sequence, rocksdb::Slice::size(), rocksdb::ParsedInternalKey::type, and rocksdb::ParsedInternalKey::user_key.

Referenced by rocksdb::InternalKeyPropertiesCollector::Add(), rocksdb::UserKeyTablePropertiesCollector::Add(), rocksdb::DBTest::AllEntriesFor(), BuildTable(), rocksdb::InternalKey::DebugString(), rocksdb::InternalDumpCommand::DoCommand(), rocksdb::DBImpl::DoCompactionWork(), rocksdb::KeyConvertingIterator::key(), rocksdb::MergeHelper::MergeUntil(), PrintContents(), rocksdb::SstFileReader::ReadSequential(), SaveValue(), TEST(), and TestKey().

                                                        {
  const size_t n = internal_key.size();
  if (n < 8) return false;
  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
  unsigned char c = num & 0xff;
  result->sequence = num >> 8;
  result->type = static_cast<ValueType>(c);
  result->user_key = Slice(internal_key.data(), n - 8);
  return (c <= static_cast<unsigned char>(kValueTypeForSeek));
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::path_

(

""

)

Definition at line 478 of file ldb_cmd.cc.

References rocksdb::LDBCommandExecuteResult::FAILED(), and verbose_().

Referenced by beast::ParsedURL::ParsedURL().

{
  verbose_ = IsFlagPresent(flags, ARG_VERBOSE);

  map<string, string>::const_iterator itr = options.find(ARG_PATH);
  if (itr != options.end()) {
    path_ = itr->second;
    if (path_.empty()) {
      exec_state_ = LDBCommandExecuteResult::FAILED("--path: missing pathname");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PrefixScanInit

(

DBTest *

dbtest)

Definition at line 4720 of file db_test.cc.

References ASSERT_OK, rocksdb::DBImpl::CompactRange(), rocksdb::DBTest::dbfull(), rocksdb::DBTest::Put(), and rocksdb::DBImpl::TEST_FlushMemTable().

Referenced by TEST().

                                    {
  char buf[100];
  std::string keystr;
  const int small_range_sstfiles = 5;
  const int big_range_sstfiles = 5;

  // Generate 11 sst files with the following prefix ranges.
  // GROUP 0: [0,10]                              (level 1)
  // GROUP 1: [1,2], [2,3], [3,4], [4,5], [5, 6]  (level 0)
  // GROUP 2: [0,6], [0,7], [0,8], [0,9], [0,10]  (level 0)
  //
  // A seek with the previous API would do 11 random I/Os (to all the
  // files).  With the new API and a prefix filter enabled, we should
  // only do 2 random I/O, to the 2 files containing the key.

  // GROUP 0
  snprintf(buf, sizeof(buf), "%02d______:start", 0);
  keystr = std::string(buf);
  ASSERT_OK(dbtest->Put(keystr, keystr));
  snprintf(buf, sizeof(buf), "%02d______:end", 10);
  keystr = std::string(buf);
  ASSERT_OK(dbtest->Put(keystr, keystr));
  dbtest->dbfull()->TEST_FlushMemTable();
  dbtest->dbfull()->CompactRange(nullptr, nullptr); // move to level 1

  // GROUP 1
  for (int i = 1; i <= small_range_sstfiles; i++) {
    snprintf(buf, sizeof(buf), "%02d______:start", i);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    snprintf(buf, sizeof(buf), "%02d______:end", i+1);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    dbtest->dbfull()->TEST_FlushMemTable();
  }

  // GROUP 2
  for (int i = 1; i <= big_range_sstfiles; i++) {
    std::string keystr;
    snprintf(buf, sizeof(buf), "%02d______:start", 0);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    snprintf(buf, sizeof(buf), "%02d______:end",
             small_range_sstfiles+i+1);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    dbtest->dbfull()->TEST_FlushMemTable();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::print_header_

(

false

)

Referenced by print_values_().

Here is the caller graph for this function:

rocksdb::print_old_levels_

(

false

)

Definition at line 969 of file ldb_cmd.cc.

References rocksdb::LDBCommandExecuteResult::FAILED(), and new_levels_().

                             {


  ParseIntOption(option_map_, ARG_NEW_LEVELS, new_levels_, exec_state_);
  print_old_levels_ = IsFlagPresent(flags, ARG_PRINT_OLD_LEVELS);

  if(new_levels_ <= 0) {
    exec_state_ = LDBCommandExecuteResult::FAILED(
           " Use --" + ARG_NEW_LEVELS + " to specify a new level number\n");
  }
}

Here is the call graph for this function:

rocksdb::print_stats_

(

false

)

Definition at line 763 of file ldb_cmd.cc.

References count_delim_(), count_only_(), delim_(), rocksdb::LDBCommandExecuteResult::FAILED(), HexToString(), max_keys_(), null_from_(), and null_to_().

Referenced by is_input_key_hex_().

                        {

  map<string, string>::const_iterator itr = options.find(ARG_FROM);
  if (itr != options.end()) {
    null_from_ = false;
    from_ = itr->second;
  }

  itr = options.find(ARG_TO);
  if (itr != options.end()) {
    null_to_ = false;
    to_ = itr->second;
  }

  itr = options.find(ARG_MAX_KEYS);
  if (itr != options.end()) {
    try {
      max_keys_ = stoi(itr->second);
    } catch(const invalid_argument&) {
      exec_state_ = LDBCommandExecuteResult::FAILED(ARG_MAX_KEYS +
                        " has an invalid value");
    } catch(const out_of_range&) {
      exec_state_ = LDBCommandExecuteResult::FAILED(ARG_MAX_KEYS +
                        " has a value out-of-range");
    }
  }
  itr = options.find(ARG_COUNT_DELIM);
  if (itr != options.end()) {
    delim_ = itr->second;
    count_delim_ = true;
  } else {
    count_delim_ = IsFlagPresent(flags, ARG_COUNT_DELIM);
    delim_=".";
  }

  print_stats_ = IsFlagPresent(flags, ARG_STATS);
  count_only_ = IsFlagPresent(flags, ARG_COUNT_ONLY);

  if (is_key_hex_) {
    if (!null_from_) {
      from_ = HexToString(from_);
    }
    if (!null_to_) {
      to_ = HexToString(to_);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::print_values_

(

false

)

Definition at line 1259 of file ldb_cmd.cc.

References rocksdb::LDBCommandExecuteResult::FAILED(), and print_header_().

                                               {

  wal_file_.clear();

  map<string, string>::const_iterator itr = options.find(ARG_WAL_FILE);
  if (itr != options.end()) {
    wal_file_ = itr->second;
  }


  print_header_ = IsFlagPresent(flags, ARG_PRINT_HEADER);
  print_values_ = IsFlagPresent(flags, ARG_PRINT_VALUE);
  if (wal_file_.empty()) {
    exec_state_ = LDBCommandExecuteResult::FAILED(
                    "Argument " + ARG_WAL_FILE + " must be specified.");
  }
}

Here is the call graph for this function:

void rocksdb::PrintBucketCounts	(	const vector< uint64_t > &	bucket_counts,
		int	ttl_start,
		int	ttl_end,
		int	bucket_size,
		int	num_buckets
	)

Definition at line 572 of file ldb_cmd.cc.

References ReadableTime().

Referenced by rocksdb::DBDumperCommand::DoCommand().

                                                     {
  int time_point = ttl_start;
  for(int i = 0; i < num_buckets - 1; i++, time_point += bucket_size) {
    fprintf(stdout, "Keys in range %s to %s : %lu\n",
            ReadableTime(time_point).c_str(),
            ReadableTime(time_point + bucket_size).c_str(),
            (unsigned long)bucket_counts[i]);
  }
  fprintf(stdout, "Keys in range %s to %s : %lu\n",
          ReadableTime(time_point).c_str(),
          ReadableTime(ttl_end).c_str(),
          (unsigned long)bucket_counts[num_buckets - 1]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string rocksdb::PrintContents ( WriteBatch *  b)

static

Definition at line 22 of file write_batch_test.cc.

References ASSERT_TRUE, BytewiseComparator(), rocksdb::WriteBatchInternal::Count(), rocksdb::WriteBatchInternal::InsertInto(), rocksdb::Iterator::key(), kTypeDeletion, kTypeLogData, kTypeMerge, kTypeValue, mem, rocksdb::Iterator::Next(), NumberToString(), rocksdb::Status::ok(), ParseInternalKey(), rocksdb::Iterator::SeekToFirst(), rocksdb::ParsedInternalKey::sequence, rocksdb::Slice::ToString(), rocksdb::Status::ToString(), rocksdb::ParsedInternalKey::type, rocksdb::ParsedInternalKey::user_key, rocksdb::Iterator::Valid(), and rocksdb::Iterator::value().

Referenced by TEST().

                                              {
  InternalKeyComparator cmp(BytewiseComparator());
  auto factory = std::make_shared<SkipListFactory>();
  MemTable* mem = new MemTable(cmp, factory);
  mem->Ref();
  std::string state;
  Options options;
  Status s = WriteBatchInternal::InsertInto(b, mem, &options);
  int count = 0;
  Iterator* iter = mem->NewIterator();
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    ParsedInternalKey ikey;
    memset((void *)&ikey, 0, sizeof(ikey));
    ASSERT_TRUE(ParseInternalKey(iter->key(), &ikey));
    switch (ikey.type) {
      case kTypeValue:
        state.append("Put(");
        state.append(ikey.user_key.ToString());
        state.append(", ");
        state.append(iter->value().ToString());
        state.append(")");
        count++;
        break;
      case kTypeMerge:
        state.append("Merge(");
        state.append(ikey.user_key.ToString());
        state.append(", ");
        state.append(iter->value().ToString());
        state.append(")");
        count++;
        break;
      case kTypeDeletion:
        state.append("Delete(");
        state.append(ikey.user_key.ToString());
        state.append(")");
        count++;
        break;
      case kTypeLogData:
        assert(false);
        break;
    }
    state.append("@");
    state.append(NumberToString(ikey.sequence));
  }
  delete iter;
  if (!s.ok()) {
    state.append(s.ToString());
  } else if (count != WriteBatchInternal::Count(b)) {
    state.append("CountMismatch()");
  }
  mem->Unref();
  return state;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::ProfileKeyComparison

(

)

Definition at line 167 of file perf_context_test.cc.

References rocksdb::HistogramImpl::Add(), db, DestroyDB(), FLAGS_random_key, FLAGS_total_keys, rocksdb::DBImpl::Get(), kDbName, OpenDb(), perf_context, rocksdb::DBImpl::Put(), rocksdb::PerfContext::Reset(), beast::IP::to_string(), rocksdb::HistogramImpl::ToString(), rocksdb::PerfContext::user_key_comparison_count, and value.

Referenced by TEST().

                            {
  DestroyDB(kDbName, Options());    // Start this test with a fresh DB

  auto db = OpenDb();

  WriteOptions write_options;
  ReadOptions read_options;

  HistogramImpl hist_put;
  HistogramImpl hist_get;

  std::cout << "Inserting " << FLAGS_total_keys << " key/value pairs\n...\n";

  std::vector<int> keys;
  for (int i = 0; i < FLAGS_total_keys; ++i) {
    keys.push_back(i);
  }

  if (FLAGS_random_key) {
    std::random_shuffle(keys.begin(), keys.end());
  }

  for (const int i : keys) {
    std::string key = "k" + std::to_string(i);
    std::string value = "v" + std::to_string(i);

    perf_context.Reset();
    db->Put(write_options, key, value);
    hist_put.Add(perf_context.user_key_comparison_count);

    perf_context.Reset();
    db->Get(read_options, key, &value);
    hist_get.Add(perf_context.user_key_comparison_count);
  }

  std::cout << "Put uesr key comparison: \n" << hist_put.ToString()
            << "Get uesr key comparison: \n" << hist_get.ToString();

}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PutFixed32	(	std::string *	dst,
		uint32_t	value
	)

Definition at line 42 of file coding.cc.

References EncodeFixed32(), and value.

Referenced by rocksdb::SimpleTableBuilder::Add(), rocksdb::TestHashFilter::CreateFilter(), EncodeKey(), rocksdb::Footer::EncodeTo(), rocksdb::BlockBuilder::Finish(), rocksdb::FilterBlockBuilder::Finish(), TEST(), and rocksdb::Blob::ToString().

                                                {
  char buf[sizeof(value)];
  EncodeFixed32(buf, value);
  dst->append(buf, sizeof(buf));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PutFixed64	(	std::string *	dst,
		uint64_t	value
	)

Definition at line 48 of file coding.cc.

References EncodeFixed64(), and value.

Referenced by rocksdb::SimpleTableBuilder::Add(), AppendInternalKey(), rocksdb::InternalKeyComparator::FindShortestSeparator(), rocksdb::InternalKeyComparator::FindShortSuccessor(), rocksdb::SimpleTableBuilder::Finish(), Key(), and TEST().

                                                {
  char buf[sizeof(value)];
  EncodeFixed64(buf, value);
  dst->append(buf, sizeof(buf));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PutLengthPrefixedSlice	(	std::string *	dst,
		const Slice &	value
	)

Definition at line 105 of file coding.cc.

References rocksdb::Slice::data(), PutVarint32(), and rocksdb::Slice::size().

Referenced by rocksdb::WriteBatch::Delete(), rocksdb::VersionEdit::EncodeTo(), rocksdb::WriteBatch::Merge(), rocksdb::WriteBatch::Put(), rocksdb::WriteBatch::PutLogData(), and TEST().

                                                                {
  PutVarint32(dst, value.size());
  dst->append(value.data(), value.size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PutLengthPrefixedSliceParts	(	std::string *	dst,
		const SliceParts &	slice_parts
	)

Definition at line 110 of file coding.cc.

References rocksdb::Slice::data(), rocksdb::SliceParts::num_parts, rocksdb::SliceParts::parts, PutVarint32(), and rocksdb::Slice::size().

Referenced by rocksdb::WriteBatch::Put().

                                                                {
  uint32_t total_bytes = 0;
  for (int i = 0; i < slice_parts.num_parts; ++i) {
    total_bytes += slice_parts.parts[i].size();
  }
  PutVarint32(dst, total_bytes);
  for (int i = 0; i < slice_parts.num_parts; ++i) {
    dst->append(slice_parts.parts[i].data(), slice_parts.parts[i].size());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PutVarint32	(	std::string *	dst,
		uint32_t	v
	)

Definition at line 82 of file coding.cc.

References EncodeVarint32().

Referenced by rocksdb::BlockBuilder::Add(), EncodeKey(), rocksdb::VersionEdit::EncodeTo(), rocksdb::RegularKeysStartWithA::Finish(), PutLengthPrefixedSlice(), PutLengthPrefixedSliceParts(), and TEST().

                                             {
  char buf[5];
  char* ptr = EncodeVarint32(buf, v);
  dst->append(buf, ptr - buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::PutVarint64	(	std::string *	dst,
		uint64_t	v
	)

Definition at line 99 of file coding.cc.

References EncodeVarint64().

Referenced by rocksdb::BlockHandle::EncodeTo(), rocksdb::VersionEdit::EncodeTo(), rocksdb::InternalKeyPropertiesCollector::Finish(), and TEST().

                                             {
  char buf[10];
  char* ptr = EncodeVarint64(buf, v);
  dst->append(buf, ptr - buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string rocksdb::RandomKey ( Random *  rnd, int  minimum = 0  )

static

Definition at line 4532 of file db_test.cc.

References rocksdb::Random::OneIn(), rocksdb::test::RandomKey(), rocksdb::Random::Skewed(), and rocksdb::Random::Uniform().

Referenced by TEST().

                                                         {
  int len;
  do {
    len = (rnd->OneIn(3)
           ? 1                // Short sometimes to encourage collisions
           : (rnd->OneIn(100) ? rnd->Skewed(10) : rnd->Uniform(10)));
  } while (len < minimum);
  return test::RandomKey(rnd, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string rocksdb::RandomString ( Random *  rnd, int  len  )

static

Definition at line 23 of file block_test.cc.

References rocksdb::test::RandomString().

                                                    {
  std::string r;
  test::RandomString(rnd, len, &r);
  return r;
}

Here is the call graph for this function:

static std::string rocksdb::RandomString ( Random *  rnd, int  len  )

static

Definition at line 52 of file db_test.cc.

References rocksdb::test::RandomString().

Referenced by DataPumpThreadBody(), MinLevelHelper(), TEST(), and WorkerThreadBody().

                                                    {
  std::string r;
  test::RandomString(rnd, len, &r);
  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string rocksdb::RandomString ( Random *  rnd, int  len  )

static

Definition at line 749 of file simple_table_db_test.cc.

References rocksdb::test::RandomString().

                                                    {
  std::string r;
  test::RandomString(rnd, len, &r);
  return r;
}

Here is the call graph for this function:

static std::string rocksdb::RandomString ( Random *  rnd, int  len  )

static

Definition at line 864 of file table_test.cc.

References rocksdb::test::RandomString().

                                                    {
  std::string r;
  test::RandomString(rnd, len, &r);
  return r;
}

Here is the call graph for this function:

string rocksdb::ReadableTime

(

int

unixtime)

Definition at line 554 of file ldb_cmd.cc.

Referenced by rocksdb::DBDumperCommand::DoCommand(), rocksdb::ScanCommand::DoCommand(), and PrintBucketCounts().

                                  {
  char time_buffer [80];
  time_t rawtime = unixtime;
  struct tm * timeinfo = localtime(&rawtime);
  strftime(time_buffer, 80, "%c", timeinfo);
  return string(time_buffer);
}

Here is the caller graph for this function:

Status rocksdb::ReadBlockContents	(	RandomAccessFile *	file,
		const ReadOptions &	options,
		const BlockHandle &	handle,
		BlockContents *	result,
		Env *	env,
		bool	do_uncompress
	)

Definition at line 75 of file format.cc.

References rocksdb::PerfContext::block_checksum_time, rocksdb::PerfContext::block_decompress_time, rocksdb::PerfContext::block_read_byte, rocksdb::PerfContext::block_read_count, rocksdb::PerfContext::block_read_time, BumpPerfCount(), BumpPerfTime(), rocksdb::BlockContents::cachable, rocksdb::BlockContents::compression_type, rocksdb::Status::Corruption(), rocksdb::BlockContents::data, DecodeFixed32(), rocksdb::BlockContents::heap_allocated, kBlockTrailerSize, kNoCompression, rocksdb::BlockHandle::offset(), rocksdb::Status::OK(), rocksdb::Status::ok(), perf_context, rocksdb::RandomAccessFile::Read(), rocksdb::BlockHandle::size(), StartPerfTimer(), UncompressBlockContents(), rocksdb::crc32c::Unmask(), rocksdb::crc32c::Value(), and rocksdb::ReadOptions::verify_checksums.

Referenced by rocksdb::BlockBasedTable::ReadFilter(), and rocksdb::BlockBasedTable::ReadProperties().

                                             {
  result->data = Slice();
  result->cachable = false;
  result->heap_allocated = false;

  // Read the block contents as well as the type/crc footer.
  // See table_builder.cc for the code that built this structure.
  size_t n = static_cast<size_t>(handle.size());
  char* buf = new char[n + kBlockTrailerSize];
  Slice contents;

  StopWatchNano timer(env);
  StartPerfTimer(&timer);
  Status s = file->Read(handle.offset(), n + kBlockTrailerSize, &contents, buf);
  BumpPerfCount(&perf_context.block_read_count);
  BumpPerfCount(&perf_context.block_read_byte, n + kBlockTrailerSize);
  BumpPerfTime(&perf_context.block_read_time, &timer);

  if (!s.ok()) {
    delete[] buf;
    return s;
  }
  if (contents.size() != n + kBlockTrailerSize) {
    delete[] buf;
    return Status::Corruption("truncated block read");
  }

  // Check the crc of the type and the block contents
  const char* data = contents.data();    // Pointer to where Read put the data
  if (options.verify_checksums) {
    const uint32_t crc = crc32c::Unmask(DecodeFixed32(data + n + 1));
    const uint32_t actual = crc32c::Value(data, n + 1);
    if (actual != crc) {
      delete[] buf;
      s = Status::Corruption("block checksum mismatch");
      return s;
    }
    BumpPerfTime(&perf_context.block_checksum_time, &timer);
  }

  // If the caller has requested that the block not be uncompressed
  if (!do_uncompress || data[n] == kNoCompression) {
    if (data != buf) {
      // File implementation gave us pointer to some other data.
      // Use it directly under the assumption that it will be live
      // while the file is open.
      delete[] buf;
      result->data = Slice(data, n);
      result->heap_allocated = false;
      result->cachable = false;  // Do not double-cache
    } else {
      result->data = Slice(buf, n);
      result->heap_allocated = true;
      result->cachable = true;
    }
    result->compression_type = (rocksdb::CompressionType)data[n];
    s =  Status::OK();
  } else {
    s = UncompressBlockContents(data, n, result);
    delete[] buf;
  }
  BumpPerfTime(&perf_context.block_decompress_time, &timer);
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Status rocksdb::ReadFileToString	(	Env *	env,
		const std::string &	fname,
		std::string *	data
	)

Definition at line 92 of file env.cc.

References rocksdb::Slice::data(), rocksdb::Slice::empty(), rocksdb::Env::NewSequentialFile(), rocksdb::Status::ok(), rocksdb::SequentialFile::Read(), and rocksdb::Slice::size().

Referenced by rocksdb::CorruptionTest::Corrupt(), rocksdb::Env::GenerateUniqueId(), and rocksdb::VersionSet::Recover().

                                                                           {
  EnvOptions soptions;
  data->clear();
  unique_ptr<SequentialFile> file;
  Status s = env->NewSequentialFile(fname, &file, soptions);
  if (!s.ok()) {
    return s;
  }
  static const int kBufferSize = 8192;
  char* space = new char[kBufferSize];
  while (true) {
    Slice fragment;
    s = file->Read(kBufferSize, &fragment, space);
    if (!s.ok()) {
      break;
    }
    data->append(fragment.data(), fragment.size());
    if (fragment.empty()) {
      break;
    }
  }
  delete[] space;
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SequenceNumber rocksdb::ReadRecords	(	std::unique_ptr< TransactionLogIterator > &	iter,
		int &	count
	)

Definition at line 3994 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, rocksdb::TransactionLogIterator::GetBatch(), rocksdb::TransactionLogIterator::Next(), rocksdb::BatchResult::sequence, rocksdb::TransactionLogIterator::status(), and rocksdb::TransactionLogIterator::Valid().

Referenced by ExpectRecords(), and TEST().

                {
  count = 0;
  SequenceNumber lastSequence = 0;
  BatchResult res;
  while (iter->Valid()) {
    res = iter->GetBatch();
    ASSERT_TRUE(res.sequence > lastSequence);
    ++count;
    lastSequence = res.sequence;
    ASSERT_OK(iter->status());
    iter->Next();
  }
  return res.sequence;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::RecordTick ( std::shared_ptr< Statistics >  statistics, Tickers  ticker, uint64_t  count = 1  )

inline

Definition at line 280 of file statistics.h.

References HISTOGRAM_ENUM_MAX, HistogramsNameMap, TICKER_ENUM_MAX, and TickersNameMap.

Referenced by rocksdb::BlockBasedTable::BlockReader(), rocksdb::DBImpl::DoCompactionWork(), rocksdb::TableCache::FindTable(), rocksdb::BlockBasedTable::Get(), rocksdb::Version::Get(), rocksdb::MemTable::Get(), rocksdb::BlockBasedTable::GetBlock(), rocksdb::BlockBasedTable::GetFilter(), rocksdb::DBImpl::GetImpl(), rocksdb::DBImpl::GetUpdatesSince(), rocksdb::DBImpl::MakeRoomForWrite(), rocksdb::MergeHelper::MergeUntil(), rocksdb::DBImpl::MultiGet(), rocksdb::BlockBasedTable::PrefixMayMatch(), SaveValue(), and rocksdb::DBImpl::Write().

                                           {
  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
  if (statistics) {
    statistics->recordTick(ticker, count);
  }
}

Here is the caller graph for this function:

Status rocksdb::RepairDB	(	const std::string &	dbname,
		const Options &	options
	)

Definition at line 385 of file repair.cc.

Referenced by leveldb_repair_db(), rocksdb::CorruptionTest::RepairDB(), and TEST().

                                                                 {
  Repairer repairer(dbname, options);
  return repairer.Run();
}

Here is the caller graph for this function:

static void rocksdb::RunConcurrent ( int  run)

static

Definition at line 353 of file skiplist_test.cc.

References ConcurrentReader(), rocksdb::Env::Default(), rocksdb::TestState::DONE, rocksdb::TestState::quit_flag_, rocksdb::test::RandomSeed(), rocksdb::port::AtomicPointer::Release_Store(), rocksdb::TestState::RUNNING, rocksdb::Env::Schedule(), rocksdb::TestState::t_, rocksdb::TestState::Wait(), and rocksdb::ConcurrentTest::WriteStep().

Referenced by TEST().

                                   {
  const int seed = test::RandomSeed() + (run * 100);
  Random rnd(seed);
  const int N = 1000;
  const int kSize = 1000;
  for (int i = 0; i < N; i++) {
    if ((i % 100) == 0) {
      fprintf(stderr, "Run %d of %d\n", i, N);
    }
    TestState state(seed + 1);
    Env::Default()->Schedule(ConcurrentReader, &state);
    state.Wait(TestState::RUNNING);
    for (int i = 0; i < kSize; i++) {
      state.t_.WriteStep(&rnd);
    }
    state.quit_flag_.Release_Store(&state);  // Any non-nullptr arg will do
    state.Wait(TestState::DONE);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Options rocksdb::SanitizeOptions	(	const std::string &	dbname,
		const InternalKeyComparator *	icmp,
		const InternalFilterPolicy *	ipolicy,
		const Options &	src
	)

Definition at line 120 of file db_impl.cc.

References rocksdb::Options::arena_block_size, rocksdb::Options::block_cache, rocksdb::Options::block_size, rocksdb::Options::block_size_deviation, ClipToRange(), rocksdb::Options::compaction_filter, rocksdb::Options::comparator, rocksdb::Options::compression_per_level, CreateLoggerFromOptions(), rocksdb::Options::db_log_dir, dbname, rocksdb::Options::env, rocksdb::Options::filter_policy, rocksdb::Options::hard_rate_limit, rocksdb::Options::info_log, Log(), rocksdb::Options::max_mem_compaction_level, rocksdb::Options::max_open_files, rocksdb::Options::max_write_buffer_number, rocksdb::Options::memtable_factory, ripple::min(), rocksdb::Options::min_write_buffer_number_to_merge, NewLRUCache(), rocksdb::Options::no_block_cache, rocksdb::Options::num_levels, rocksdb::Status::ok(), rocksdb::Options::prefix_extractor, rocksdb::Options::soft_rate_limit, rocksdb::Options::table_properties_collectors, rocksdb::Options::wal_dir, and rocksdb::Options::write_buffer_size.

Referenced by DestroyDB(), and TEST().

                                            {
  Options result = src;
  result.comparator = icmp;
  result.filter_policy = (src.filter_policy != nullptr) ? ipolicy : nullptr;
  ClipToRange(&result.max_open_files,            20,     1000000);
  ClipToRange(&result.write_buffer_size,         ((size_t)64)<<10,
                                                 ((size_t)64)<<30);
  ClipToRange(&result.block_size,                1<<10,  4<<20);

  // if user sets arena_block_size, we trust user to use this value. Otherwise,
  // calculate a proper value from writer_buffer_size;
  if (result.arena_block_size <= 0) {
    result.arena_block_size = result.write_buffer_size / 10;
  }

  result.min_write_buffer_number_to_merge = std::min(
    result.min_write_buffer_number_to_merge, result.max_write_buffer_number-1);
  if (result.info_log == nullptr) {
    Status s = CreateLoggerFromOptions(dbname, result.db_log_dir, src.env,
                                       result, &result.info_log);
    if (!s.ok()) {
      // No place suitable for logging
      result.info_log = nullptr;
    }
  }
  if (result.block_cache == nullptr && !result.no_block_cache) {
    result.block_cache = NewLRUCache(8 << 20);
  }
  result.compression_per_level = src.compression_per_level;
  if (result.block_size_deviation < 0 || result.block_size_deviation > 100) {
    result.block_size_deviation = 0;
  }
  if (result.max_mem_compaction_level >= result.num_levels) {
    result.max_mem_compaction_level = result.num_levels - 1;
  }
  if (result.soft_rate_limit > result.hard_rate_limit) {
    result.soft_rate_limit = result.hard_rate_limit;
  }
  if (result.compaction_filter) {
    Log(result.info_log, "Compaction filter specified, ignore factory");
  }
  if (result.prefix_extractor) {
    // If a prefix extractor has been supplied and a PrefixHashRepFactory is
    // being used, make sure that the latter uses the former as its transform
    // function.
    auto factory = dynamic_cast<PrefixHashRepFactory*>(
      result.memtable_factory.get());
    if (factory &&
        factory->GetTransform() != result.prefix_extractor) {
      Log(result.info_log, "A prefix hash representation factory was supplied "
          "whose prefix extractor does not match options.prefix_extractor. "
          "Falling back to skip list representation factory");
      result.memtable_factory = std::make_shared<SkipListFactory>();
    } else if (factory) {
      Log(result.info_log, "Prefix hash memtable rep is in use.");
    }
  }

  if (result.wal_dir.empty()) {
    // Use dbname as default
    result.wal_dir = dbname;
  }

  // -- Sanitize the table properties collector
  // All user defined properties collectors will be wrapped by
  // UserKeyTablePropertiesCollector since for them they only have the
  // knowledge of the user keys; internal keys are invisible to them.
  auto& collectors = result.table_properties_collectors;
  for (size_t i = 0; i < result.table_properties_collectors.size(); ++i) {
    assert(collectors[i]);
    collectors[i] =
      std::make_shared<UserKeyTablePropertiesCollector>(collectors[i]);
  }

  // Add collector to collect internal key statistics
  collectors.push_back(
      std::make_shared<InternalKeyPropertiesCollector>()
  );

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool rocksdb::SaveDidIO	(	void *	arg,
		const Slice &	key,
		const Slice &	value,
		bool	didIO
	)

Definition at line 1053 of file block_based_table_reader.cc.

References arg.

Referenced by rocksdb::BlockBasedTable::TEST_KeyInCache().

                                                                            {
  *reinterpret_cast<bool*>(arg) = didIO;
  return false;
}

Here is the caller graph for this function:

static bool rocksdb::SaveValue ( void *  arg, const Slice &  ikey, const Slice &  v, bool  didIO  )

static

Definition at line 310 of file version_set.cc.

References arg, rocksdb::Slice::data(), didIO, kTypeDeletion, kTypeLogData, kTypeMerge, kTypeValue, NUMBER_MERGE_FAILURES, ParseInternalKey(), RecordTick(), rocksdb::Slice::size(), beast::asio::swap(), rocksdb::Slice::ToString(), rocksdb::ParsedInternalKey::type, and rocksdb::ParsedInternalKey::user_key.

Referenced by rocksdb::Version::Get().

                                                                               {
  Saver* s = reinterpret_cast<Saver*>(arg);
  std::deque<std::string>* const ops = s->merge_operands; // shorter alias
  std::string merge_result;  // temporary area for merge results later

  assert(s != nullptr && ops != nullptr);

  ParsedInternalKey parsed_key;
  // TODO: didIO and Merge?
  s->didIO = didIO;
  if (!ParseInternalKey(ikey, &parsed_key)) {
    // TODO: what about corrupt during Merge?
    s->state = kCorrupt;
  } else {
    if (s->ucmp->Compare(parsed_key.user_key, s->user_key) == 0) {
      // Key matches. Process it
      switch (parsed_key.type) {
        case kTypeValue:
          if (kNotFound == s->state) {
            s->state = kFound;
            s->value->assign(v.data(), v.size());
          } else if (kMerge == s->state) {
            assert(s->merge_operator != nullptr);
            s->state = kFound;
            if (!s->merge_operator->FullMerge(s->user_key, &v, *ops,
                                              s->value, s->logger)) {
              RecordTick(s->statistics, NUMBER_MERGE_FAILURES);
              s->state = kCorrupt;
            }
          } else {
            assert(false);
          }
          return false;

        case kTypeDeletion:
          if (kNotFound == s->state) {
            s->state = kDeleted;
          } else if (kMerge == s->state) {
            s->state = kFound;
            if (!s->merge_operator->FullMerge(s->user_key, nullptr, *ops,
                                              s->value, s->logger)) {
              RecordTick(s->statistics, NUMBER_MERGE_FAILURES);
              s->state = kCorrupt;
            }
          } else {
            assert(false);
          }
          return false;

        case kTypeMerge:
          assert(s->state == kNotFound || s->state == kMerge);
          s->state = kMerge;
          ops->push_front(v.ToString());
          while (ops->size() >= 2) {
            // Attempt to merge operands together via user associateive merge
            if (s->merge_operator->PartialMerge(s->user_key,
                                                Slice((*ops)[0]),
                                                Slice((*ops)[1]),
                                                &merge_result,
                                                s->logger)) {
              ops->pop_front();
              swap(ops->front(), merge_result);
            } else {
              // Associative merge returns false ==> stack the operands
              break;
            }
          }
          return true;

        case kTypeLogData:
          assert(false);
          break;
      }
    }
  }

  // s->state could be Corrupt, merge or notfound

  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rocksdb::SetBool ( void *  ptr)

static

Definition at line 34 of file env_test.cc.

Referenced by TEST().

                               {
  reinterpret_cast<port::AtomicPointer*>(ptr)->NoBarrier_Store(ptr);
}

Here is the caller graph for this function:

Status rocksdb::SetCurrentFile	(	Env *	env,
		const std::string &	dbname,
		uint64_t	descriptor_number
	)

Definition at line 233 of file filename.cc.

References CurrentFileName(), rocksdb::Env::DeleteFile(), DescriptorFileName(), rocksdb::Status::ok(), rocksdb::Slice::remove_prefix(), rocksdb::Env::RenameFile(), rocksdb::Slice::starts_with(), TempFileName(), rocksdb::Slice::ToString(), and WriteStringToFileSync().

Referenced by rocksdb::VersionSet::LogAndApply(), and rocksdb::DBImpl::NewDB().

                                                  {
  // Remove leading "dbname/" and add newline to manifest file name
  std::string manifest = DescriptorFileName(dbname, descriptor_number);
  Slice contents = manifest;
  assert(contents.starts_with(dbname + "/"));
  contents.remove_prefix(dbname.size() + 1);
  std::string tmp = TempFileName(dbname, descriptor_number);
  Status s = WriteStringToFileSync(env, contents.ToString() + "\n", tmp);
  if (s.ok()) {
    s = env->RenameFile(tmp, CurrentFileName(dbname));
  }
  if (!s.ok()) {
    env->DeleteFile(tmp);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Status rocksdb::SetIdentityFile	(	Env *	env,
		const std::string &	dbname
	)

Definition at line 251 of file filename.cc.

References rocksdb::Env::DeleteFile(), rocksdb::Env::GenerateUniqueId(), IdentityFileName(), rocksdb::Status::ok(), rocksdb::Env::RenameFile(), TempFileName(), and WriteStringToFileSync().

Referenced by rocksdb::DBImpl::Recover().

                                                          {
  std::string id = env->GenerateUniqueId();
  assert(!id.empty());
  // Reserve the filename dbname/000000.dbtmp for the temporary identity file
  std::string tmp = TempFileName(dbname, 0);
  Status s = WriteStringToFileSync(env, id, tmp);
  if (s.ok()) {
    s = env->RenameFile(tmp, IdentityFileName(dbname));
  }
  if (!s.ok()) {
    env->DeleteFile(tmp);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::SetPerfLevel

(

PerfLevel

level)

Definition at line 13 of file perf_context.cc.

References perf_level.

Referenced by TEST().

{ perf_level = level; }

Here is the caller graph for this function:

void rocksdb::SetTickerCount ( std::shared_ptr< Statistics >  statistics, Tickers  ticker, uint64_t  count  )

inline

Definition at line 290 of file statistics.h.

References HISTOGRAM_ENUM_MAX, HistogramsNameMap, TICKER_ENUM_MAX, and TickersNameMap.

Referenced by rocksdb::DBImpl::Recover(), and rocksdb::DBImpl::Write().

                                           {
  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
  if (statistics) {
    statistics->setTickerCount(ticker, count);
  }
}

Here is the caller graph for this function:

static std::string rocksdb::Shorten ( const std::string &  s, const std::string &  l  )

static

Definition at line 24 of file dbformat_test.cc.

References BytewiseComparator(), and rocksdb::InternalKeyComparator::FindShortestSeparator().

Referenced by TEST().

                                                                 {
  std::string result = s;
  InternalKeyComparator(BytewiseComparator()).FindShortestSeparator(&result, l);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string rocksdb::ShortSuccessor ( const std::string &  s)

static

Definition at line 30 of file dbformat_test.cc.

References BytewiseComparator(), and rocksdb::InternalKeyComparator::FindShortSuccessor().

Referenced by TEST().

                                                    {
  std::string result = s;
  InternalKeyComparator(BytewiseComparator()).FindShortSuccessor(&result);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const TestKey* rocksdb::SliceToTestKey ( const Slice &  slice)

inline

Definition at line 43 of file prefix_test.cc.

References rocksdb::Slice::data().

Referenced by rocksdb::TestKeyComparator::Compare(), and TEST().

                                                         {
  return (const TestKey*)slice.data();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::SnappyCompressionSupported ( const CompressionOptions &  options)

static

Definition at line 34 of file db_test.cc.

References rocksdb::Slice::data(), Json::in(), rocksdb::Slice::size(), and rocksdb::port::Snappy_Compress().

Referenced by GenerateArgList(), MinLevelToCompress(), and TEST().

                                                                          {
  std::string out;
  Slice in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  return port::Snappy_Compress(options, in.data(), in.size(), &out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::SnappyCompressionSupported ( )

static

Definition at line 452 of file table_test.cc.

References rocksdb::Slice::data(), Json::in(), rocksdb::Slice::size(), and rocksdb::port::Snappy_Compress().

                                         {
  std::string out;
  Slice in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  return port::Snappy_Compress(Options().compression_opts,
                               in.data(), in.size(),
                               &out);
}

Here is the call graph for this function:

bool rocksdb::SomeFileOverlapsRange	(	const InternalKeyComparator &	icmp,
		bool	disjoint_sorted_files,
		const std::vector< FileMetaData * > &	files,
		const Slice *	smallest_user_key,
		const Slice *	largest_user_key
	)

Definition at line 95 of file version_set.cc.

References AfterFile(), BeforeFile(), rocksdb::InternalKey::Encode(), ripple::f, FindFile(), kMaxSequenceNumber, kValueTypeForSeek, ucmp, and rocksdb::InternalKeyComparator::user_comparator().

Referenced by rocksdb::Version::OverlapInLevel(), and rocksdb::FindFileTest::Overlaps().

                                   {
  const Comparator* ucmp = icmp.user_comparator();
  if (!disjoint_sorted_files) {
    // Need to check against all files
    for (size_t i = 0; i < files.size(); i++) {
      const FileMetaData* f = files[i];
      if (AfterFile(ucmp, smallest_user_key, f) ||
          BeforeFile(ucmp, largest_user_key, f)) {
        // No overlap
      } else {
        return true;  // Overlap
      }
    }
    return false;
  }

  // Binary search over file list
  uint32_t index = 0;
  if (smallest_user_key != nullptr) {
    // Find the earliest possible internal key for smallest_user_key
    InternalKey small(*smallest_user_key, kMaxSequenceNumber,kValueTypeForSeek);
    index = FindFile(icmp, files, small.Encode());
  }

  if (index >= files.size()) {
    // beginning of range is after all files, so no overlap.
    return false;
  }

  return !BeforeFile(ucmp, largest_user_key, files[index]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::start_key_specified_

(

false

)

Referenced by max_keys_scanned_().

Here is the caller graph for this function:

void rocksdb::StartPerfTimer ( StopWatchNano *  timer)

inline

Definition at line 14 of file perf_context_imp.h.

References kEnableTime, perf_level, and rocksdb::StopWatchNano::Start().

Referenced by ReadBlockContents(), and rocksdb::DBImpl::Write().

                                                 {
  if (perf_level >= PerfLevel::kEnableTime) {
    timer->Start();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::string > rocksdb::stringSplit	(	string	arg,
		char	delim
	)

Definition at line 17 of file string_util.cc.

Referenced by rocksdb::LDBCommand::InitFromCmdLineArgs(), and main().

                                                   {
  vector<string> splits;
  stringstream ss(arg);
  string item;
  while(getline(ss, item, delim)) {
    splits.push_back(item);
  }
  return splits;
}

Here is the caller graph for this function:

std::string rocksdb::TableFileName	(	const std::string &	name,
		uint64_t	number
	)

Definition at line 73 of file filename.cc.

References MakeFileName().

Referenced by BuildTable(), rocksdb::TableCache::FindTable(), rocksdb::DBImpl::GetLiveFiles(), rocksdb::VersionSet::GetLiveFilesMetaData(), rocksdb::DBImpl::OpenCompactionOutputFile(), rocksdb::DBImpl::PurgeObsoleteFiles(), and TEST().

                                                                {
  assert(number > 0);
  return MakeFileName(name, number, "sst");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::TableReaderBenchmark	(	Options &	opts,
		EnvOptions &	env_options,
		ReadOptions &	read_options,
		int	num_keys1,
		int	num_keys2,
		int	num_iter,
		int	prefix_len,
		bool	if_query_empty_keys,
		bool	for_iterator,
		bool	through_db
	)

Definition at line 54 of file table_reader_bench.cc.

References rocksdb::TableBuilder::Add(), rocksdb::HistogramImpl::Add(), arg, ASSERT_OK, ASSERT_TRUE, rocksdb::WritableFile::Close(), db, dbname, rocksdb::Env::Default(), rocksdb::Env::DeleteFile(), DestroyDB(), DummySaveValue(), env, rocksdb::TableBuilder::Finish(), rocksdb::DB::Flush(), rocksdb::TableReader::Get(), rocksdb::DB::Get(), rocksdb::Env::GetFileSize(), rocksdb::Iterator::key(), kNoCompression, MakeKey(), rocksdb::TableReader::NewIterator(), rocksdb::DB::NewIterator(), rocksdb::Env::NewRandomAccessFile(), rocksdb::Env::NewWritableFile(), rocksdb::Iterator::Next(), rocksdb::Env::NowMicros(), rocksdb::DB::Open(), std::chrono::prefix, rocksdb::ReadOptions::prefix, rocksdb::DB::Put(), rocksdb::Iterator::Seek(), rocksdb::Options::table_factory, rocksdb::test::TmpDir(), rocksdb::HistogramImpl::ToString(), rocksdb::Random::Uniform(), and rocksdb::Iterator::Valid().

Referenced by main().

                                           {
  Slice prefix = Slice();

  std::string file_name = test::TmpDir()
      + "/rocksdb_table_reader_benchmark";
  std::string dbname = test::TmpDir() + "/rocksdb_table_reader_bench_db";
  ReadOptions ro;
  WriteOptions wo;
  unique_ptr<WritableFile> file;
  Env* env = Env::Default();
  TableBuilder* tb = nullptr;
  DB* db = nullptr;
  Status s;
  if (!through_db) {
    env->NewWritableFile(file_name, &file, env_options);
    tb = opts.table_factory->GetTableBuilder(opts, file.get(),
                                             CompressionType::kNoCompression);
  } else {
    s = DB::Open(opts, dbname, &db);
    ASSERT_OK(s);
    ASSERT_TRUE(db != nullptr);
  }
  // Populate slightly more than 1M keys
  for (int i = 0; i < num_keys1; i++) {
    for (int j = 0; j < num_keys2; j++) {
      std::string key = MakeKey(i * 2, j, through_db);
      if (!through_db) {
        tb->Add(key, key);
      } else {
        db->Put(wo, key, key);
      }
    }
  }
  if (!through_db) {
    tb->Finish();
    file->Close();
  } else {
    db->Flush(FlushOptions());
  }

  unique_ptr<TableReader> table_reader;
  unique_ptr<RandomAccessFile> raf;
  if (!through_db) {
    Status s = env->NewRandomAccessFile(file_name, &raf, env_options);
    uint64_t file_size;
    env->GetFileSize(file_name, &file_size);
    s = opts.table_factory->GetTableReader(opts, env_options, std::move(raf),
                                           file_size, &table_reader);
  }

  Random rnd(301);
  std::string result;
  HistogramImpl hist;

  void* arg = nullptr;
  for (int it = 0; it < num_iter; it++) {
    for (int i = 0; i < num_keys1; i++) {
      for (int j = 0; j < num_keys2; j++) {
        int r1 = rnd.Uniform(num_keys1) * 2;
        int r2 = rnd.Uniform(num_keys2);
        if (if_query_empty_keys) {
          r1++;
          r2 = num_keys2 * 2 - r2;
        }

        if (!for_iterator) {
          // Query one existing key;
          std::string key = MakeKey(r1, r2, through_db);
          uint64_t start_micros = env->NowMicros();
          port::MemoryBarrier();
          if (!through_db) {
            s = table_reader->Get(ro, key, arg, DummySaveValue, nullptr);
          } else {
            s = db->Get(ro, key, &result);
          }
          port::MemoryBarrier();
          hist.Add(env->NowMicros() - start_micros);
        } else {
          int r2_len;
          if (if_query_empty_keys) {
            r2_len = 0;
          } else {
            r2_len = rnd.Uniform(num_keys2) + 1;
            if (r2_len + r2 > num_keys2) {
              r2_len = num_keys2 - r2;
            }
          }
          std::string start_key = MakeKey(r1, r2, through_db);
          std::string end_key = MakeKey(r1, r2 + r2_len, through_db);
          if (prefix_len < 16) {
            prefix = Slice(start_key.data(), prefix_len);
            read_options.prefix = &prefix;
          }
          uint64_t total_time = 0;
          uint64_t start_micros = env->NowMicros();
          port::MemoryBarrier();
          Iterator* iter;
          if (!through_db) {
            iter = table_reader->NewIterator(read_options);
          } else {
            iter = db->NewIterator(read_options);
          }
          int count = 0;
          for(iter->Seek(start_key); iter->Valid(); iter->Next()) {
            if (if_query_empty_keys) {
              break;
            }
            // verify key;
            port::MemoryBarrier();
            total_time += env->NowMicros() - start_micros;
            assert(Slice(MakeKey(r1, r2 + count, through_db)) == iter->key());
            start_micros = env->NowMicros();
            if (++count >= r2_len) {
              break;
            }
          }
          if (count != r2_len) {
            fprintf(
                stderr, "Iterator cannot iterate expected number of entries. "
                "Expected %d but got %d\n", r2_len, count);
            assert(false);
          }
          delete iter;
          port::MemoryBarrier();
          total_time += env->NowMicros() - start_micros;
          hist.Add(total_time);
        }
      }
    }
  }

  fprintf(
      stderr,
      "==================================================="
      "====================================================\n"
      "InMemoryTableSimpleBenchmark: %20s   num_key1:  %5d   "
      "num_key2: %5d  %10s\n"
      "==================================================="
      "===================================================="
      "\nHistogram (unit: microseconds): \n%s",
      opts.table_factory->Name(), num_keys1, num_keys2,
      for_iterator? "iterator" : (if_query_empty_keys ? "empty" : "non_empty"),
      hist.ToString().c_str());
  if (!through_db) {
    env->DeleteFile(file_name);
  } else {
    delete db;
    db = nullptr;
    DestroyDB(dbname, opts);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string rocksdb::TempFileName	(	const std::string &	dbname,
		uint64_t	number
	)

Definition at line 94 of file filename.cc.

References MakeFileName().

Referenced by SetCurrentFile(), SetIdentityFile(), and TEST().

                                                                 {
  assert(number >= 0);
  return MakeFileName(dbname, number, "dbtmp");
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocksdb::TEST	(	HistogramTest	,
		BasicOperation
	)

Definition at line 14 of file histogram_test.cc.

References rocksdb::HistogramImpl::Add(), ASSERT_EQ, ASSERT_GT, ASSERT_LE, ASSERT_TRUE, rocksdb::HistogramImpl::Average(), rocksdb::HistogramImpl::Median(), and rocksdb::HistogramImpl::Percentile().

                                    {

  HistogramImpl histogram;
  for (uint64_t i = 1; i <= 100; i++) {
    histogram.Add(i);
  }

  {
    double median = histogram.Median();
    // ASSERT_LE(median, 50);
    ASSERT_GT(median, 0);
  }

  {
    double percentile100 = histogram.Percentile(100.0);
    ASSERT_LE(percentile100, 100.0);
    ASSERT_GT(percentile100, 0.0);
    double percentile99 = histogram.Percentile(99.0);
    double percentile85 = histogram.Percentile(85.0);
    ASSERT_LE(percentile99, 99.0);
    ASSERT_TRUE(percentile99 >= percentile85);
  }

  ASSERT_EQ(histogram.Average(), 50.5); // avg is acurately caluclated.
}

Here is the call graph for this function:

rocksdb::TEST	(	ArenaImplTest	,
		Empty
	)

Definition at line 18 of file arena_test.cc.

                           {
  ArenaImpl arena0;
}

rocksdb::TEST	(	Coding	,
		Fixed32
	)

Definition at line 18 of file coding_test.cc.

References ASSERT_EQ, DecodeFixed32(), and PutFixed32().

                      {
  std::string s;
  for (uint32_t v = 0; v < 100000; v++) {
    PutFixed32(&s, v);
  }

  const char* p = s.data();
  for (uint32_t v = 0; v < 100000; v++) {
    uint32_t actual = DecodeFixed32(p);
    ASSERT_EQ(v, actual);
    p += sizeof(uint32_t);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	BlobStoreTest	,
		RangeParseTest
	)

Definition at line 20 of file blob_store_test.cc.

References ASSERT_EQ, rocksdb::Blob::chunks, rand, and rocksdb::Blob::ToString().

                                    {
  Blob e;
  for (int i = 0; i < 5; ++i) {
    e.chunks.push_back(BlobChunk(rand(), rand(), rand()));
  }
  string x = e.ToString();
  Blob nx(x);

  ASSERT_EQ(nx.ToString(), x);
}

Here is the call graph for this function:

rocksdb::TEST	(	FileNameTest	,
		Parse
	)

Definition at line 21 of file filename_test.cc.

References ASSERT_EQ, ASSERT_TRUE, db, ripple::f, kCurrentFile, kDBLockFile, kDescriptorFile, kInfoLogFile, kLogFile, kMetaDatabase, kTableFile, and ParseFileName().

                          {
  Slice db;
  FileType type;
  uint64_t number;

  // Successful parses
  static struct {
    const char* fname;
    uint64_t number;
    FileType type;
  } cases[] = {
    { "100.log",            100,   kLogFile },
    { "0.log",              0,     kLogFile },
    { "0.sst",              0,     kTableFile },
    { "CURRENT",            0,     kCurrentFile },
    { "LOCK",               0,     kDBLockFile },
    { "MANIFEST-2",         2,     kDescriptorFile },
    { "MANIFEST-7",         7,     kDescriptorFile },
    { "METADB-2",           2,     kMetaDatabase },
    { "METADB-7",           7,     kMetaDatabase },
    { "LOG",                0,     kInfoLogFile },
    { "LOG.old",            0,     kInfoLogFile },
    { "18446744073709551615.log", 18446744073709551615ull, kLogFile },
  };
  for (unsigned int i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
    std::string f = cases[i].fname;
    ASSERT_TRUE(ParseFileName(f, &number, &type)) << f;
    ASSERT_EQ(cases[i].type, type) << f;
    ASSERT_EQ(cases[i].number, number) << f;
  }

  // Errors
  static const char* errors[] = {
    "",
    "foo",
    "foo-dx-100.log",
    ".log",
    "",
    "manifest",
    "CURREN",
    "CURRENTX",
    "MANIFES",
    "MANIFEST",
    "MANIFEST-",
    "XMANIFEST-3",
    "MANIFEST-3x",
    "META",
    "METADB",
    "METADB-",
    "XMETADB-3",
    "METADB-3x",
    "LOC",
    "LOCKx",
    "LO",
    "LOGx",
    "18446744073709551616.log",
    "184467440737095516150.log",
    "100",
    "100.",
    "100.lop"
  };
  for (unsigned int i = 0; i < sizeof(errors) / sizeof(errors[0]); i++) {
    std::string f = errors[i];
    ASSERT_TRUE(!ParseFileName(f, &number, &type)) << f;
  };
}

Here is the call graph for this function:

rocksdb::TEST	(	ArenaImplTest	,
		MemoryAllocatedBytes
	)

Definition at line 22 of file arena_test.cc.

References rocksdb::ArenaImpl::Allocate(), ASSERT_EQ, and rocksdb::ArenaImpl::MemoryAllocatedBytes().

                                          {
  const int N = 17;
  size_t req_sz;  //requested size
  size_t bsz = 8192;  // block size
  size_t expected_memory_allocated;

  ArenaImpl arena_impl(bsz);

  // requested size > quarter of a block:
  //   allocate requested size separately
  req_sz = 3001;
  for (int i = 0; i < N; i++) {
    arena_impl.Allocate(req_sz);
  }
  expected_memory_allocated = req_sz * N;
  ASSERT_EQ(arena_impl.MemoryAllocatedBytes(), expected_memory_allocated);

  // requested size < quarter of a block:
  //   allocate a block with the default size, then try to use unused part
  //   of the block. So one new block will be allocated for the first
  //   Allocate(99) call. All the remaining calls won't lead to new allocation.
  req_sz = 99;
  for (int i = 0; i < N; i++) {
    arena_impl.Allocate(req_sz);
  }
  expected_memory_allocated += bsz;
  ASSERT_EQ(arena_impl.MemoryAllocatedBytes(), expected_memory_allocated);

  // requested size > quarter of a block:
  //   allocate requested size separately
  req_sz = 99999999;
  for (int i = 0; i < N; i++) {
    arena_impl.Allocate(req_sz);
  }
  expected_memory_allocated += req_sz * N;
  ASSERT_EQ(arena_impl.MemoryAllocatedBytes(), expected_memory_allocated);
}

Here is the call graph for this function:

rocksdb::TEST	(	VersionEditTest	,
		EncodeDecode
	)

Definition at line 27 of file version_edit_test.cc.

References rocksdb::VersionEdit::AddFile(), rocksdb::VersionEdit::DeleteFile(), kTypeDeletion, kTypeValue, rocksdb::VersionEdit::SetCompactPointer(), rocksdb::VersionEdit::SetComparatorName(), rocksdb::VersionEdit::SetLastSequence(), rocksdb::VersionEdit::SetLogNumber(), rocksdb::VersionEdit::SetNextFile(), and TestEncodeDecode().

                                    {
  static const uint64_t kBig = 1ull << 50;

  VersionEdit edit(7);
  for (int i = 0; i < 4; i++) {
    TestEncodeDecode(edit);
    edit.AddFile(3, kBig + 300 + i, kBig + 400 + i,
                 InternalKey("foo", kBig + 500 + i, kTypeValue),
                 InternalKey("zoo", kBig + 600 + i, kTypeDeletion),
                 kBig + 500 + i,
                 kBig + 600 + i);
    edit.DeleteFile(4, kBig + 700 + i);
    edit.SetCompactPointer(i, InternalKey("x", kBig + 900 + i, kTypeValue));
  }

  edit.SetComparatorName("foo");
  edit.SetLogNumber(kBig + 100);
  edit.SetNextFile(kBig + 200);
  edit.SetLastSequence(kBig + 1000);
  TestEncodeDecode(edit);
}

Here is the call graph for this function:

rocksdb::TEST	(	MemEnvTest	,
		Basics
	)

Definition at line 30 of file memenv_test.cc.

References rocksdb::WritableFile::Append(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::Env::CreateDir(), rocksdb::Env::DeleteDir(), rocksdb::Env::DeleteFile(), env_, rocksdb::Env::FileExists(), rocksdb::Env::GetChildren(), rocksdb::Env::GetFileSize(), rocksdb::Env::NewRandomAccessFile(), rocksdb::Env::NewSequentialFile(), rocksdb::Env::NewWritableFile(), rocksdb::Status::ok(), rocksdb::Env::RenameFile(), and soptions_.

                         {
  uint64_t file_size;
  unique_ptr<WritableFile> writable_file;
  std::vector<std::string> children;

  ASSERT_OK(env_->CreateDir("/dir"));

  // Check that the directory is empty.
  ASSERT_TRUE(!env_->FileExists("/dir/non_existent"));
  ASSERT_TRUE(!env_->GetFileSize("/dir/non_existent", &file_size).ok());
  ASSERT_OK(env_->GetChildren("/dir", &children));
  ASSERT_EQ(0U, children.size());

  // Create a file.
  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
  writable_file.reset();

  // Check that the file exists.
  ASSERT_TRUE(env_->FileExists("/dir/f"));
  ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
  ASSERT_EQ(0U, file_size);
  ASSERT_OK(env_->GetChildren("/dir", &children));
  ASSERT_EQ(1U, children.size());
  ASSERT_EQ("f", children[0]);

  // Write to the file.
  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
  ASSERT_OK(writable_file->Append("abc"));
  writable_file.reset();

  // Check for expected size.
  ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
  ASSERT_EQ(3U, file_size);

  // Check that renaming works.
  ASSERT_TRUE(!env_->RenameFile("/dir/non_existent", "/dir/g").ok());
  ASSERT_OK(env_->RenameFile("/dir/f", "/dir/g"));
  ASSERT_TRUE(!env_->FileExists("/dir/f"));
  ASSERT_TRUE(env_->FileExists("/dir/g"));
  ASSERT_OK(env_->GetFileSize("/dir/g", &file_size));
  ASSERT_EQ(3U, file_size);

  // Check that opening non-existent file fails.
  unique_ptr<SequentialFile> seq_file;
  unique_ptr<RandomAccessFile> rand_file;
  ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file,
                                       soptions_).ok());
  ASSERT_TRUE(!seq_file);
  ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file,
                                         soptions_).ok());
  ASSERT_TRUE(!rand_file);

  // Check that deleting works.
  ASSERT_TRUE(!env_->DeleteFile("/dir/non_existent").ok());
  ASSERT_OK(env_->DeleteFile("/dir/g"));
  ASSERT_TRUE(!env_->FileExists("/dir/g"));
  ASSERT_OK(env_->GetChildren("/dir", &children));
  ASSERT_EQ(0U, children.size());
  ASSERT_OK(env_->DeleteDir("/dir"));
}

Here is the call graph for this function:

rocksdb::TEST	(	BlockTest	,
		SimpleTest
	)

Definition at line 32 of file block_test.cc.

References rocksdb::BlockBuilder::Add(), ASSERT_EQ, ASSERT_TRUE, rocksdb::BlockContents::cachable, rocksdb::Options::comparator, rocksdb::BlockContents::data, rocksdb::BlockBuilder::Finish(), rocksdb::BlockContents::heap_allocated, rocksdb::Iterator::key(), rocksdb::Block::NewIterator(), rocksdb::Iterator::Next(), RandomString(), rocksdb::Iterator::Seek(), rocksdb::Iterator::SeekToFirst(), rocksdb::Slice::ToString(), rocksdb::Random::Uniform(), rocksdb::Iterator::Valid(), rocksdb::Iterator::value(), and value.

                            {
  Random rnd(301);
  Options options = Options();
  std::vector<std::string> keys;
  std::vector<std::string> values;
  BlockBuilder builder(options);
  int num_records = 100000;
  char buf[10];
  char* p = &buf[0];

  // add a bunch of records to a block
  for (int i = 0; i < num_records; i++) {
    // generate random kvs
    sprintf(p, "%6d", i);
    std::string k(p);
    std::string v = RandomString(&rnd, 100); // 100 byte values

    // write kvs to the block
    Slice key(k);
    Slice value(v);
    builder.Add(key, value);

    // remember kvs in a lookaside array
    keys.push_back(k);
    values.push_back(v);
  }

  // read serialized contents of the block
  Slice rawblock = builder.Finish();

  // create block reader
  BlockContents contents;
  contents.data = rawblock;
  contents.cachable = false;
  contents.heap_allocated = false;
  Block reader(contents);

  // read contents of block sequentially
  int count = 0;
  Iterator* iter = reader.NewIterator(options.comparator);
  for (iter->SeekToFirst();iter->Valid(); count++, iter->Next()) {

    // read kv from block
    Slice k = iter->key();
    Slice v = iter->value();

    // compare with lookaside array
    ASSERT_EQ(k.ToString().compare(keys[count]), 0);
    ASSERT_EQ(v.ToString().compare(values[count]), 0);
  }
  delete iter;

  // read block contents randomly
  iter = reader.NewIterator(options.comparator);
  for (int i = 0; i < num_records; i++) {

    // find a random key in the lookaside array
    int index = rnd.Uniform(num_records);
    Slice k(keys[index]);

    // search in block for this key
    iter->Seek(k);
    ASSERT_TRUE(iter->Valid());
    Slice v = iter->value();
    ASSERT_EQ(v.ToString().compare(values[index]), 0);
  }
  delete iter;
}

Here is the call graph for this function:

rocksdb::TEST	(	BlobStoreTest	,
		SanityTest
	)

Definition at line 32 of file blob_store_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Blob::chunks, rocksdb::Env::Default(), rocksdb::BlobStore::Delete(), rocksdb::BlobStore::Put(), rocksdb::test::RandomString(), and rocksdb::test::TmpDir().

                                {
  const uint64_t block_size = 10;
  const uint32_t blocks_per_file = 20;
  Random random(5);

  BlobStore blob_store(test::TmpDir() + "/blob_store_test",
                       block_size,
                       blocks_per_file,
                       1000,
                       Env::Default());

  string buf;

  // put string of size 170
  test::RandomString(&random, 170, &buf);
  Blob r1;
  ASSERT_OK(blob_store.Put(Slice(buf), &r1));
  // use the first file
  for (size_t i = 0; i < r1.chunks.size(); ++i) {
    ASSERT_EQ(r1.chunks[0].bucket_id, 0u);
  }

  // put string of size 30
  test::RandomString(&random, 30, &buf);
  Blob r2;
  ASSERT_OK(blob_store.Put(Slice(buf), &r2));
  // use the first file
  for (size_t i = 0; i < r2.chunks.size(); ++i) {
    ASSERT_EQ(r2.chunks[0].bucket_id, 0u);
  }

  // delete blob of size 170
  ASSERT_OK(blob_store.Delete(r1));

  // put a string of size 100
  test::RandomString(&random, 100, &buf);
  Blob r3;
  ASSERT_OK(blob_store.Put(Slice(buf), &r3));
  // use the first file
  for (size_t i = 0; i < r3.chunks.size(); ++i) {
    ASSERT_EQ(r3.chunks[0].bucket_id, 0u);
  }

  // put a string of size 70
  test::RandomString(&random, 70, &buf);
  Blob r4;
  ASSERT_OK(blob_store.Put(Slice(buf), &r4));
  // use the first file
  for (size_t i = 0; i < r4.chunks.size(); ++i) {
    ASSERT_EQ(r4.chunks[0].bucket_id, 0u);
  }

  // put a string of size 5
  test::RandomString(&random, 5, &buf);
  Blob r5;
  ASSERT_OK(blob_store.Put(Slice(buf), &r5));
  // now you get to use the second file
  for (size_t i = 0; i < r5.chunks.size(); ++i) {
    ASSERT_EQ(r5.chunks[0].bucket_id, 1u);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		Fixed64
	)

Definition at line 32 of file coding_test.cc.

References ASSERT_EQ, DecodeFixed64(), and PutFixed64().

                      {
  std::string s;
  for (int power = 0; power <= 63; power++) {
    uint64_t v = static_cast<uint64_t>(1) << power;
    PutFixed64(&s, v - 1);
    PutFixed64(&s, v + 0);
    PutFixed64(&s, v + 1);
  }

  const char* p = s.data();
  for (int power = 0; power <= 63; power++) {
    uint64_t v = static_cast<uint64_t>(1) << power;
    uint64_t actual;
    actual = DecodeFixed64(p);
    ASSERT_EQ(v-1, actual);
    p += sizeof(uint64_t);

    actual = DecodeFixed64(p);
    ASSERT_EQ(v+0, actual);
    p += sizeof(uint64_t);

    actual = DecodeFixed64(p);
    ASSERT_EQ(v+1, actual);
    p += sizeof(uint64_t);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		Empty
	)

Definition at line 36 of file skiplist_test.cc.

References ASSERT_TRUE, and rocksdb::SkipList< Key, Comparator >::Contains().

                      {
  ArenaImpl arena_impl;
  TestComparator cmp;
  SkipList<Key, TestComparator> list(cmp, &arena_impl);
  ASSERT_TRUE(!list.Contains(10));

  SkipList<Key, TestComparator>::Iterator iter(&list);
  ASSERT_TRUE(!iter.Valid());
  iter.SeekToFirst();
  ASSERT_TRUE(!iter.Valid());
  iter.Seek(100);
  ASSERT_TRUE(!iter.Valid());
  iter.SeekToLast();
  ASSERT_TRUE(!iter.Valid());
}

Here is the call graph for this function:

rocksdb::TEST	(	EnvPosixTest	,
		RunImmediately
	)

Definition at line 38 of file env_test.cc.

References ASSERT_TRUE, rocksdb::Env::Default(), env_, kDelayMicros, rocksdb::port::AtomicPointer::NoBarrier_Load(), rocksdb::Env::Schedule(), SetBool(), and rocksdb::Env::SleepForMicroseconds().

                                   {
  port::AtomicPointer called (nullptr);
  env_->Schedule(&SetBool, &called);
  Env::Default()->SleepForMicroseconds(kDelayMicros);
  ASSERT_TRUE(called.NoBarrier_Load() != nullptr);
}

Here is the call graph for this function:

rocksdb::TEST	(	LockTest	,
		LockBySameThread
	)

Definition at line 39 of file filelock_test.cc.

References ASSERT_OK, and ASSERT_TRUE.

                                 {
  FileLock* lock1;
  FileLock* lock2;

  // acquire a lock on a file
  ASSERT_OK(LockFile(&lock1));

  // re-acquire the lock on the same file. This should fail.
  ASSERT_TRUE(LockFile(&lock2).IsIOError());

  // release the lock
  ASSERT_OK(UnlockFile(lock1));

}

rocksdb::TEST	(	HistogramTest	,
		EmptyHistogram
	)

Definition at line 40 of file histogram_test.cc.

References ASSERT_EQ, rocksdb::HistogramImpl::Average(), rocksdb::HistogramImpl::Median(), and rocksdb::HistogramImpl::Percentile().

                                    {
  HistogramImpl histogram;
  ASSERT_EQ(histogram.Median(), 0.0);
  ASSERT_EQ(histogram.Percentile(85.0), 0.0);
  ASSERT_EQ(histogram.Average(), 0.0);
}

Here is the call graph for this function:

rocksdb::TEST	(	EnvPosixTest	,
		RunMany
	)

Definition at line 45 of file env_test.cc.

References rocksdb::port::AtomicPointer::Acquire_Load(), ASSERT_EQ, rocksdb::Env::Default(), env_, id, kDelayMicros, rocksdb::Env::Schedule(), and rocksdb::Env::SleepForMicroseconds().

                            {
  port::AtomicPointer last_id (nullptr);

  struct CB {
    port::AtomicPointer* last_id_ptr;   // Pointer to shared slot
    uintptr_t id;             // Order# for the execution of this callback

    CB(port::AtomicPointer* p, int i) : last_id_ptr(p), id(i) { }

    static void Run(void* v) {
      CB* cb = reinterpret_cast<CB*>(v);
      void* cur = cb->last_id_ptr->NoBarrier_Load();
      ASSERT_EQ(cb->id-1, reinterpret_cast<uintptr_t>(cur));
      cb->last_id_ptr->Release_Store(reinterpret_cast<void*>(cb->id));
    }
  };

  // Schedule in different order than start time
  CB cb1(&last_id, 1);
  CB cb2(&last_id, 2);
  CB cb3(&last_id, 3);
  CB cb4(&last_id, 4);
  env_->Schedule(&CB::Run, &cb1);
  env_->Schedule(&CB::Run, &cb2);
  env_->Schedule(&CB::Run, &cb3);
  env_->Schedule(&CB::Run, &cb4);

  Env::Default()->SleepForMicroseconds(kDelayMicros);
  void* cur = last_id.Acquire_Load();
  ASSERT_EQ(4U, reinterpret_cast<uintptr_t>(cur));
}

Here is the call graph for this function:

rocksdb::TEST	(	HistogramTest	,
		ClearHistogram
	)

Definition at line 47 of file histogram_test.cc.

References rocksdb::HistogramImpl::Add(), ASSERT_EQ, rocksdb::HistogramImpl::Average(), rocksdb::HistogramImpl::Clear(), rocksdb::HistogramImpl::Median(), and rocksdb::HistogramImpl::Percentile().

                                    {
  HistogramImpl histogram;
  for (uint64_t i = 1; i <= 100; i++) {
    histogram.Add(i);
  }
  histogram.Clear();
  ASSERT_EQ(histogram.Median(), 0);
  ASSERT_EQ(histogram.Percentile(85.0), 0);
  ASSERT_EQ(histogram.Average(), 0);
}

Here is the call graph for this function:

rocksdb::TEST	(	PerfContextTest	,
		SeekIntoDeletion
	)

Definition at line 52 of file perf_context_test.cc.

References rocksdb::HistogramImpl::Add(), ASSERT_TRUE, db, rocksdb::Env::Default(), rocksdb::DBImpl::Delete(), DestroyDB(), rocksdb::StopWatchNano::ElapsedNanos(), FLAGS_total_keys, rocksdb::DBImpl::Get(), rocksdb::PerfContext::internal_delete_skipped_count, rocksdb::PerfContext::internal_key_skipped_count, kDbName, rocksdb::DBImpl::NewIterator(), OpenDb(), perf_context, rocksdb::DBImpl::Put(), rocksdb::PerfContext::Reset(), beast::IP::to_string(), rocksdb::HistogramImpl::ToString(), rocksdb::PerfContext::user_key_comparison_count, and value.

                                        {
  DestroyDB(kDbName, Options());
  auto db = OpenDb();
  WriteOptions write_options;
  ReadOptions read_options;

  for (int i = 0; i < FLAGS_total_keys; ++i) {
    std::string key = "k" + std::to_string(i);
    std::string value = "v" + std::to_string(i);

    db->Put(write_options, key, value);
  }

  for (int i = 0; i < FLAGS_total_keys -1 ; ++i) {
    std::string key = "k" + std::to_string(i);
    db->Delete(write_options, key);
  }

  HistogramImpl hist_get;
  HistogramImpl hist_get_time;
  for (int i = 0; i < FLAGS_total_keys - 1; ++i) {
    std::string key = "k" + std::to_string(i);
    std::string value;

    perf_context.Reset();
    StopWatchNano timer(Env::Default(), true);
    auto status = db->Get(read_options, key, &value);
    auto elapsed_nanos = timer.ElapsedNanos();
    ASSERT_TRUE(status.IsNotFound());
    hist_get.Add(perf_context.user_key_comparison_count);
    hist_get_time.Add(elapsed_nanos);
  }

  std::cout << "Get uesr key comparison: \n" << hist_get.ToString()
            << "Get time: \n" << hist_get_time.ToString();

  HistogramImpl hist_seek_to_first;
  std::unique_ptr<Iterator> iter(db->NewIterator(read_options));

  perf_context.Reset();
  StopWatchNano timer(Env::Default(), true);
  iter->SeekToFirst();
  hist_seek_to_first.Add(perf_context.user_key_comparison_count);
  auto elapsed_nanos = timer.ElapsedNanos();

  std::cout << "SeekToFirst uesr key comparison: \n" << hist_seek_to_first.ToString()
            << "ikey skipped: " << perf_context.internal_key_skipped_count << "\n"
            << "idelete skipped: " << perf_context.internal_delete_skipped_count << "\n"
            << "elapsed: " << elapsed_nanos << "\n";

  HistogramImpl hist_seek;
  for (int i = 0; i < FLAGS_total_keys; ++i) {
    std::unique_ptr<Iterator> iter(db->NewIterator(read_options));
    std::string key = "k" + std::to_string(i);

    perf_context.Reset();
    StopWatchNano timer(Env::Default(), true);
    iter->Seek(key);
    auto elapsed_nanos = timer.ElapsedNanos();
    hist_seek.Add(perf_context.user_key_comparison_count);
    std::cout << "seek cmp: " << perf_context.user_key_comparison_count
              << " ikey skipped " << perf_context.internal_key_skipped_count
              << " idelete skipped " << perf_context.internal_delete_skipped_count
              << " elapsed: " << elapsed_nanos << "ns\n";

    perf_context.Reset();
    ASSERT_TRUE(iter->Valid());
    StopWatchNano timer2(Env::Default(), true);
    iter->Next();
    auto elapsed_nanos2 = timer2.ElapsedNanos();
    std::cout << "next cmp: " << perf_context.user_key_comparison_count
              << "elapsed: " << elapsed_nanos2 << "ns\n";
  }

  std::cout << "Seek uesr key comparison: \n" << hist_seek.ToString();
}

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		InsertAndLookup
	)

Definition at line 52 of file skiplist_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::SkipList< Key, Comparator >::Contains(), rocksdb::SkipList< Key, Comparator >::Insert(), rocksdb::SkipList< Key, Comparator >::Iterator::key(), rocksdb::Random::Next(), rocksdb::SkipList< Key, Comparator >::Iterator::Next(), rocksdb::SkipList< Key, Comparator >::Iterator::Prev(), R, rocksdb::SkipList< Key, Comparator >::Iterator::Seek(), rocksdb::SkipList< Key, Comparator >::Iterator::SeekToFirst(), rocksdb::SkipList< Key, Comparator >::Iterator::SeekToLast(), and rocksdb::SkipList< Key, Comparator >::Iterator::Valid().

                                {
  const int N = 2000;
  const int R = 5000;
  Random rnd(1000);
  std::set<Key> keys;
  ArenaImpl arena_impl;
  TestComparator cmp;
  SkipList<Key, TestComparator> list(cmp, &arena_impl);
  for (int i = 0; i < N; i++) {
    Key key = rnd.Next() % R;
    if (keys.insert(key).second) {
      list.Insert(key);
    }
  }

  for (int i = 0; i < R; i++) {
    if (list.Contains(i)) {
      ASSERT_EQ(keys.count(i), 1U);
    } else {
      ASSERT_EQ(keys.count(i), 0U);
    }
  }

  // Simple iterator tests
  {
    SkipList<Key, TestComparator>::Iterator iter(&list);
    ASSERT_TRUE(!iter.Valid());

    iter.Seek(0);
    ASSERT_TRUE(iter.Valid());
    ASSERT_EQ(*(keys.begin()), iter.key());

    iter.SeekToFirst();
    ASSERT_TRUE(iter.Valid());
    ASSERT_EQ(*(keys.begin()), iter.key());

    iter.SeekToLast();
    ASSERT_TRUE(iter.Valid());
    ASSERT_EQ(*(keys.rbegin()), iter.key());
  }

  // Forward iteration test
  for (int i = 0; i < R; i++) {
    SkipList<Key, TestComparator>::Iterator iter(&list);
    iter.Seek(i);

    // Compare against model iterator
    std::set<Key>::iterator model_iter = keys.lower_bound(i);
    for (int j = 0; j < 3; j++) {
      if (model_iter == keys.end()) {
        ASSERT_TRUE(!iter.Valid());
        break;
      } else {
        ASSERT_TRUE(iter.Valid());
        ASSERT_EQ(*model_iter, iter.key());
        ++model_iter;
        iter.Next();
      }
    }
  }

  // Backward iteration test
  {
    SkipList<Key, TestComparator>::Iterator iter(&list);
    iter.SeekToLast();

    // Compare against model iterator
    for (std::set<Key>::reverse_iterator model_iter = keys.rbegin();
         model_iter != keys.rend();
         ++model_iter) {
      ASSERT_TRUE(iter.Valid());
      ASSERT_EQ(*model_iter, iter.key());
      iter.Prev();
    }
    ASSERT_TRUE(!iter.Valid());
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	RedisListsTest	,
		SimpleTest
	)

Definition at line 53 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, AssertListEq(), rocksdb::RedisLists::Index(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PushRight(), and rocksdb::RedisLists::Range().

                                 {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Simple PushRight (should return the new length each time)
  ASSERT_EQ(redis.PushRight("k1", "v1"), 1);
  ASSERT_EQ(redis.PushRight("k1", "v2"), 2);
  ASSERT_EQ(redis.PushRight("k1", "v3"), 3);

  // Check Length and Index() functions
  ASSERT_EQ(redis.Length("k1"), 3);        // Check length
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "v1");   // Check valid indices
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "v2");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "v3");

  // Check range function and vectors
  std::vector<std::string> result = redis.Range("k1", 0, 2);   // Get the list
  std::vector<std::string> expected_result(3);
  expected_result[0] = "v1";
  expected_result[1] = "v2";
  expected_result[2] = "v3";
  AssertListEq(result, expected_result);
}

Here is the call graph for this function:

rocksdb::TEST	(	FormatTest	,
		InternalKey_EncodeDecode
	)

Definition at line 54 of file dbformat_test.cc.

References kTypeDeletion, kTypeValue, and TestKey().

                                           {
  const char* keys[] = { "", "k", "hello", "longggggggggggggggggggggg" };
  const uint64_t seq[] = {
    1, 2, 3,
    (1ull << 8) - 1, 1ull << 8, (1ull << 8) + 1,
    (1ull << 16) - 1, 1ull << 16, (1ull << 16) + 1,
    (1ull << 32) - 1, 1ull << 32, (1ull << 32) + 1
  };
  for (unsigned int k = 0; k < sizeof(keys) / sizeof(keys[0]); k++) {
    for (unsigned int s = 0; s < sizeof(seq) / sizeof(seq[0]); s++) {
      TestKey(keys[k], seq[s], kTypeValue);
      TestKey("hello", 1, kTypeDeletion);
    }
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	FindFileTest	,
		Empty
	)

Definition at line 56 of file version_set_test.cc.

References ASSERT_EQ, and ASSERT_TRUE.

                          {
  ASSERT_EQ(0, Find("foo"));
  ASSERT_TRUE(! Overlaps("a", "z"));
  ASSERT_TRUE(! Overlaps(nullptr, "z"));
  ASSERT_TRUE(! Overlaps("a", nullptr));
  ASSERT_TRUE(! Overlaps(nullptr, nullptr));
}

rocksdb::TEST	(	FilterBlockTest	,
		EmptyBuilder
	)

Definition at line 57 of file filter_block_test.cc.

References ASSERT_EQ, ASSERT_TRUE, EscapeString(), rocksdb::FilterBlockBuilder::Finish(), rocksdb::FilterBlockReader::KeyMayMatch(), and options_.

                                    {
  FilterBlockBuilder builder(options_);
  Slice block = builder.Finish();
  ASSERT_EQ("\\x00\\x00\\x00\\x00\\x0b", EscapeString(block));
  FilterBlockReader reader(options_, block);
  ASSERT_TRUE(reader.KeyMayMatch(0, "foo"));
  ASSERT_TRUE(reader.KeyMayMatch(100000, "foo"));
}

Here is the call graph for this function:

rocksdb::TEST	(	ArenaImplTest	,
		Simple
	)

Definition at line 60 of file arena_test.cc.

References rocksdb::ArenaImpl::Allocate(), rocksdb::ArenaImpl::AllocateAligned(), rocksdb::ArenaImpl::ApproximateMemoryUsage(), ASSERT_EQ, ASSERT_GE, ASSERT_LE, rocksdb::Random::OneIn(), and rocksdb::Random::Uniform().

                            {
  std::vector<std::pair<size_t, char*> > allocated;
  ArenaImpl arena_impl;
  const int N = 100000;
  size_t bytes = 0;
  Random rnd(301);
  for (int i = 0; i < N; i++) {
    size_t s;
    if (i % (N / 10) == 0) {
      s = i;
    } else {
      s = rnd.OneIn(4000) ? rnd.Uniform(6000) :
          (rnd.OneIn(10) ? rnd.Uniform(100) : rnd.Uniform(20));
    }
    if (s == 0) {
      // Our arena disallows size 0 allocations.
      s = 1;
    }
    char* r;
    if (rnd.OneIn(10)) {
      r = arena_impl.AllocateAligned(s);
    } else {
      r = arena_impl.Allocate(s);
    }

    for (unsigned int b = 0; b < s; b++) {
      // Fill the "i"th allocation with a known bit pattern
      r[b] = i % 256;
    }
    bytes += s;
    allocated.push_back(std::make_pair(s, r));
    ASSERT_GE(arena_impl.ApproximateMemoryUsage(), bytes);
    if (i > N/10) {
      ASSERT_LE(arena_impl.ApproximateMemoryUsage(), bytes * 1.10);
    }
  }
  for (unsigned int i = 0; i < allocated.size(); i++) {
    size_t num_bytes = allocated[i].first;
    const char* p = allocated[i].second;
    for (unsigned int b = 0; b < num_bytes; b++) {
      // Check the "i"th allocation for the known bit pattern
      ASSERT_EQ(int(p[b]) & 0xff, (int)(i % 256));
    }
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		EncodingOutput
	)

Definition at line 60 of file coding_test.cc.

References ASSERT_EQ, PutFixed32(), and PutFixed64().

                             {
  std::string dst;
  PutFixed32(&dst, 0x04030201);
  ASSERT_EQ(4U, dst.size());
  ASSERT_EQ(0x01, static_cast<int>(dst[0]));
  ASSERT_EQ(0x02, static_cast<int>(dst[1]));
  ASSERT_EQ(0x03, static_cast<int>(dst[2]));
  ASSERT_EQ(0x04, static_cast<int>(dst[3]));

  dst.clear();
  PutFixed64(&dst, 0x0807060504030201ull);
  ASSERT_EQ(8U, dst.size());
  ASSERT_EQ(0x01, static_cast<int>(dst[0]));
  ASSERT_EQ(0x02, static_cast<int>(dst[1]));
  ASSERT_EQ(0x03, static_cast<int>(dst[2]));
  ASSERT_EQ(0x04, static_cast<int>(dst[3]));
  ASSERT_EQ(0x05, static_cast<int>(dst[4]));
  ASSERT_EQ(0x06, static_cast<int>(dst[5]));
  ASSERT_EQ(0x07, static_cast<int>(dst[6]));
  ASSERT_EQ(0x08, static_cast<int>(dst[7]));
}

Here is the call graph for this function:

rocksdb::TEST	(	FindFileTest	,
		Single
	)

Definition at line 64 of file version_set_test.cc.

References ASSERT_EQ, and ASSERT_TRUE.

                           {
  Add("p", "q");
  ASSERT_EQ(0, Find("a"));
  ASSERT_EQ(0, Find("p"));
  ASSERT_EQ(0, Find("p1"));
  ASSERT_EQ(0, Find("q"));
  ASSERT_EQ(1, Find("q1"));
  ASSERT_EQ(1, Find("z"));

  ASSERT_TRUE(! Overlaps("a", "b"));
  ASSERT_TRUE(! Overlaps("z1", "z2"));
  ASSERT_TRUE(Overlaps("a", "p"));
  ASSERT_TRUE(Overlaps("a", "q"));
  ASSERT_TRUE(Overlaps("a", "z"));
  ASSERT_TRUE(Overlaps("p", "p1"));
  ASSERT_TRUE(Overlaps("p", "q"));
  ASSERT_TRUE(Overlaps("p", "z"));
  ASSERT_TRUE(Overlaps("p1", "p2"));
  ASSERT_TRUE(Overlaps("p1", "z"));
  ASSERT_TRUE(Overlaps("q", "q"));
  ASSERT_TRUE(Overlaps("q", "q1"));

  ASSERT_TRUE(! Overlaps(nullptr, "j"));
  ASSERT_TRUE(! Overlaps("r", nullptr));
  ASSERT_TRUE(Overlaps(nullptr, "p"));
  ASSERT_TRUE(Overlaps(nullptr, "p1"));
  ASSERT_TRUE(Overlaps("q", nullptr));
  ASSERT_TRUE(Overlaps(nullptr, nullptr));
}

rocksdb::TEST	(	FilterBlockTest	,
		SingleChunk
	)

Definition at line 66 of file filter_block_test.cc.

References rocksdb::FilterBlockBuilder::AddKey(), ASSERT_TRUE, rocksdb::FilterBlockBuilder::Finish(), rocksdb::FilterBlockReader::KeyMayMatch(), options_, and rocksdb::FilterBlockBuilder::StartBlock().

                                   {
  FilterBlockBuilder builder(options_);
  builder.StartBlock(100);
  builder.AddKey("foo");
  builder.AddKey("bar");
  builder.AddKey("box");
  builder.StartBlock(200);
  builder.AddKey("box");
  builder.StartBlock(300);
  builder.AddKey("hello");
  Slice block = builder.Finish();
  FilterBlockReader reader(options_, block);
  ASSERT_TRUE(reader.KeyMayMatch(100, "foo"));
  ASSERT_TRUE(reader.KeyMayMatch(100, "bar"));
  ASSERT_TRUE(reader.KeyMayMatch(100, "box"));
  ASSERT_TRUE(reader.KeyMayMatch(100, "hello"));
  ASSERT_TRUE(reader.KeyMayMatch(100, "foo"));
  ASSERT_TRUE(! reader.KeyMayMatch(100, "missing"));
  ASSERT_TRUE(! reader.KeyMayMatch(100, "other"));
}

Here is the call graph for this function:

rocksdb::TEST	(	FormatTest	,
		InternalKeyShortSeparator
	)

Definition at line 70 of file dbformat_test.cc.

References ASSERT_EQ, IKey(), kMaxSequenceNumber, kTypeDeletion, kTypeValue, kValueTypeForSeek, and Shorten().

                                            {
  // When user keys are same
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("foo", 99, kTypeValue)));
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("foo", 101, kTypeValue)));
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("foo", 100, kTypeValue)));
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("foo", 100, kTypeDeletion)));

  // When user keys are misordered
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("bar", 99, kTypeValue)));

  // When user keys are different, but correctly ordered
  ASSERT_EQ(IKey("g", kMaxSequenceNumber, kValueTypeForSeek),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("hello", 200, kTypeValue)));

  // When start user key is prefix of limit user key
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("foobar", 200, kTypeValue)));

  // When limit user key is prefix of start user key
  ASSERT_EQ(IKey("foobar", 100, kTypeValue),
            Shorten(IKey("foobar", 100, kTypeValue),
                    IKey("foo", 200, kTypeValue)));
}

Here is the call graph for this function:

rocksdb::TEST	(	WriteBatchTest	,
		Empty
	)

Definition at line 78 of file write_batch_test.cc.

References ASSERT_EQ, rocksdb::WriteBatchInternal::Count(), rocksdb::WriteBatch::Count(), and PrintContents().

                            {
  WriteBatch batch;
  ASSERT_EQ("", PrintContents(&batch));
  ASSERT_EQ(0, WriteBatchInternal::Count(&batch));
  ASSERT_EQ(0, batch.Count());
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		Varint32
	)

Definition at line 82 of file coding_test.cc.

References ASSERT_EQ, ASSERT_TRUE, GetVarint32Ptr(), PutVarint32(), and VarintLength().

                       {
  std::string s;
  for (uint32_t i = 0; i < (32 * 32); i++) {
    uint32_t v = (i / 32) << (i % 32);
    PutVarint32(&s, v);
  }

  const char* p = s.data();
  const char* limit = p + s.size();
  for (uint32_t i = 0; i < (32 * 32); i++) {
    uint32_t expected = (i / 32) << (i % 32);
    uint32_t actual;
    const char* start = p;
    p = GetVarint32Ptr(p, limit, &actual);
    ASSERT_TRUE(p != nullptr);
    ASSERT_EQ(expected, actual);
    ASSERT_EQ(VarintLength(actual), p - start);
  }
  ASSERT_EQ(p, s.data() + s.size());
}

Here is the call graph for this function:

rocksdb::TEST	(	RedisListsTest	,
		SimpleTest2
	)

Definition at line 82 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, AssertListEq(), rocksdb::RedisLists::Index(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PushLeft(), and rocksdb::RedisLists::Range().

                                  {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Simple PushRight
  ASSERT_EQ(redis.PushLeft("k1", "v3"), 1);
  ASSERT_EQ(redis.PushLeft("k1", "v2"), 2);
  ASSERT_EQ(redis.PushLeft("k1", "v1"), 3);

  // Check Length and Index() functions
  ASSERT_EQ(redis.Length("k1"), 3);        // Check length
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "v1");   // Check valid indices
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "v2");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "v3");

  // Check range function and vectors
  std::vector<std::string> result = redis.Range("k1", 0, 2);   // Get the list
  std::vector<std::string> expected_result(3);
  expected_result[0] = "v1";
  expected_result[1] = "v2";
  expected_result[2] = "v3";
  AssertListEq(result, expected_result);
}

Here is the call graph for this function:

rocksdb::TEST	(	WriteBatchTest	,
		Multiple
	)

Definition at line 85 of file write_batch_test.cc.

References ASSERT_EQ, rocksdb::WriteBatchInternal::Count(), rocksdb::WriteBatch::Count(), rocksdb::WriteBatch::Delete(), PrintContents(), rocksdb::WriteBatch::Put(), rocksdb::WriteBatchInternal::Sequence(), and rocksdb::WriteBatchInternal::SetSequence().

                               {
  WriteBatch batch;
  batch.Put(Slice("foo"), Slice("bar"));
  batch.Delete(Slice("box"));
  batch.Put(Slice("baz"), Slice("boo"));
  WriteBatchInternal::SetSequence(&batch, 100);
  ASSERT_EQ(100U, WriteBatchInternal::Sequence(&batch));
  ASSERT_EQ(3, WriteBatchInternal::Count(&batch));
  ASSERT_EQ("Put(baz, boo)@102"
            "Delete(box)@101"
            "Put(foo, bar)@100",
            PrintContents(&batch));
  ASSERT_EQ(3, batch.Count());
}

Here is the call graph for this function:

rocksdb::TEST	(	FilterBlockTest	,
		MultiChunk
	)

Definition at line 87 of file filter_block_test.cc.

References rocksdb::FilterBlockBuilder::AddKey(), ASSERT_TRUE, rocksdb::FilterBlockBuilder::Finish(), rocksdb::FilterBlockReader::KeyMayMatch(), options_, and rocksdb::FilterBlockBuilder::StartBlock().

                                  {
  FilterBlockBuilder builder(options_);

  // First filter
  builder.StartBlock(0);
  builder.AddKey("foo");
  builder.StartBlock(2000);
  builder.AddKey("bar");

  // Second filter
  builder.StartBlock(3100);
  builder.AddKey("box");

  // Third filter is empty

  // Last filter
  builder.StartBlock(9000);
  builder.AddKey("box");
  builder.AddKey("hello");

  Slice block = builder.Finish();
  FilterBlockReader reader(options_, block);

  // Check first filter
  ASSERT_TRUE(reader.KeyMayMatch(0, "foo"));
  ASSERT_TRUE(reader.KeyMayMatch(2000, "bar"));
  ASSERT_TRUE(! reader.KeyMayMatch(0, "box"));
  ASSERT_TRUE(! reader.KeyMayMatch(0, "hello"));

  // Check second filter
  ASSERT_TRUE(reader.KeyMayMatch(3100, "box"));
  ASSERT_TRUE(! reader.KeyMayMatch(3100, "foo"));
  ASSERT_TRUE(! reader.KeyMayMatch(3100, "bar"));
  ASSERT_TRUE(! reader.KeyMayMatch(3100, "hello"));

  // Check third filter (empty)
  ASSERT_TRUE(! reader.KeyMayMatch(4100, "foo"));
  ASSERT_TRUE(! reader.KeyMayMatch(4100, "bar"));
  ASSERT_TRUE(! reader.KeyMayMatch(4100, "box"));
  ASSERT_TRUE(! reader.KeyMayMatch(4100, "hello"));

  // Check last filter
  ASSERT_TRUE(reader.KeyMayMatch(9000, "box"));
  ASSERT_TRUE(reader.KeyMayMatch(9000, "hello"));
  ASSERT_TRUE(! reader.KeyMayMatch(9000, "foo"));
  ASSERT_TRUE(! reader.KeyMayMatch(9000, "bar"));
}

Here is the call graph for this function:

rocksdb::TEST	(	FileNameTest	,
		Construction
	)

Definition at line 88 of file filename_test.cc.

References ASSERT_EQ, ASSERT_TRUE, CurrentFileName(), DescriptorFileName(), kCurrentFile, kDBLockFile, kDescriptorFile, kLogFile, kMetaDatabase, kTableFile, kTempFile, LockFileName(), LogFileName(), MetaDatabaseName(), ParseFileName(), TableFileName(), and TempFileName().

                                 {
  uint64_t number;
  FileType type;
  std::string fname;

  fname = CurrentFileName("foo");
  ASSERT_EQ("foo/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(0U, number);
  ASSERT_EQ(kCurrentFile, type);

  fname = LockFileName("foo");
  ASSERT_EQ("foo/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(0U, number);
  ASSERT_EQ(kDBLockFile, type);

  fname = LogFileName("foo", 192);
  ASSERT_EQ("foo/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(192U, number);
  ASSERT_EQ(kLogFile, type);

  fname = TableFileName("bar", 200);
  ASSERT_EQ("bar/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(200U, number);
  ASSERT_EQ(kTableFile, type);

  fname = DescriptorFileName("bar", 100);
  ASSERT_EQ("bar/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(100U, number);
  ASSERT_EQ(kDescriptorFile, type);

  fname = TempFileName("tmp", 999);
  ASSERT_EQ("tmp/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(999U, number);
  ASSERT_EQ(kTempFile, type);

  fname = MetaDatabaseName("met", 100);
  ASSERT_EQ("met/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  ASSERT_EQ(100U, number);
  ASSERT_EQ(kMetaDatabase, type);
}

Here is the call graph for this function:

rocksdb::TEST	(	EnvPosixTest	,
		StartThread
	)

Definition at line 91 of file env_test.cc.

References ASSERT_EQ, rocksdb::Env::Default(), env_, kDelayMicros, rocksdb::port::Mutex::Lock(), rocksdb::State::mu, rocksdb::State::num_running, rocksdb::Env::SleepForMicroseconds(), rocksdb::Env::StartThread(), ThreadBody(), rocksdb::port::Mutex::Unlock(), and rocksdb::State::val.

                                {
  State state;
  state.val = 0;
  state.num_running = 3;
  for (int i = 0; i < 3; i++) {
    env_->StartThread(&ThreadBody, &state);
  }
  while (true) {
    state.mu.Lock();
    int num = state.num_running;
    state.mu.Unlock();
    if (num == 0) {
      break;
    }
    Env::Default()->SleepForMicroseconds(kDelayMicros);
  }
  ASSERT_EQ(state.val, 3);
}

Here is the call graph for this function:

rocksdb::TEST	(	MemEnvTest	,
		ReadWrite
	)

Definition at line 91 of file memenv_test.cc.

References rocksdb::WritableFile::Append(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::Slice::compare(), rocksdb::Env::CreateDir(), env_, rocksdb::Env::NewRandomAccessFile(), rocksdb::Env::NewSequentialFile(), rocksdb::Env::NewWritableFile(), rocksdb::Status::ok(), rocksdb::SequentialFile::Read(), rocksdb::RandomAccessFile::Read(), rocksdb::Slice::size(), rocksdb::SequentialFile::Skip(), and soptions_.

                            {
  unique_ptr<WritableFile> writable_file;
  unique_ptr<SequentialFile> seq_file;
  unique_ptr<RandomAccessFile> rand_file;
  Slice result;
  char scratch[100];

  ASSERT_OK(env_->CreateDir("/dir"));

  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
  ASSERT_OK(writable_file->Append("hello "));
  ASSERT_OK(writable_file->Append("world"));
  writable_file.reset();

  // Read sequentially.
  ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file, soptions_));
  ASSERT_OK(seq_file->Read(5, &result, scratch)); // Read "hello".
  ASSERT_EQ(0, result.compare("hello"));
  ASSERT_OK(seq_file->Skip(1));
  ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Read "world".
  ASSERT_EQ(0, result.compare("world"));
  ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Try reading past EOF.
  ASSERT_EQ(0U, result.size());
  ASSERT_OK(seq_file->Skip(100)); // Try to skip past end of file.
  ASSERT_OK(seq_file->Read(1000, &result, scratch));
  ASSERT_EQ(0U, result.size());

  // Random reads.
  ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file, soptions_));
  ASSERT_OK(rand_file->Read(6, 5, &result, scratch)); // Read "world".
  ASSERT_EQ(0, result.compare("world"));
  ASSERT_OK(rand_file->Read(0, 5, &result, scratch)); // Read "hello".
  ASSERT_EQ(0, result.compare("hello"));
  ASSERT_OK(rand_file->Read(10, 100, &result, scratch)); // Read "d".
  ASSERT_EQ(0, result.compare("d"));

  // Too high offset.
  ASSERT_TRUE(!rand_file->Read(1000, 5, &result, scratch).ok());
}

Here is the call graph for this function:

rocksdb::TEST	(	BloomTest	,
		EmptyFilter
	)

Definition at line 92 of file bloom_test.cc.

References ASSERT_TRUE.

                             {
  ASSERT_TRUE(! Matches("hello"));
  ASSERT_TRUE(! Matches("world"));
}

rocksdb::TEST	(	BlobStoreTest	,
		FragmentedChunksTest
	)

Definition at line 94 of file blob_store_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Blob::chunks, rocksdb::Env::Default(), rocksdb::BlobStore::Delete(), rocksdb::BlobStore::Put(), rocksdb::test::RandomString(), and rocksdb::test::TmpDir().

                                          {
  const uint64_t block_size = 10;
  const uint32_t blocks_per_file = 20;
  Random random(5);

  BlobStore blob_store(test::TmpDir() + "/blob_store_test",
                       block_size,
                       blocks_per_file,
                       1000,
                       Env::Default());

  string buf;

  vector <Blob> r(4);

  // put 4 strings of size 50
  for (int k = 0; k < 4; ++k)  {
    test::RandomString(&random, 50, &buf);
    ASSERT_OK(blob_store.Put(Slice(buf), &r[k]));
    // use the first file
    for (size_t i = 0; i < r[k].chunks.size(); ++i) {
      ASSERT_EQ(r[k].chunks[0].bucket_id, 0u);
    }
  }

  // delete the first and third
  ASSERT_OK(blob_store.Delete(r[0]));
  ASSERT_OK(blob_store.Delete(r[2]));

  // put string of size 100. it should reuse space that we deleting
  // by deleting first and third strings of size 50
  test::RandomString(&random, 100, &buf);
  Blob r2;
  ASSERT_OK(blob_store.Put(Slice(buf), &r2));
  // use the first file
  for (size_t i = 0; i < r2.chunks.size(); ++i) {
    ASSERT_EQ(r2.chunks[0].bucket_id, 0u);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	FindFileTest	,
		Multiple
	)

Definition at line 95 of file version_set_test.cc.

References ASSERT_EQ, and ASSERT_TRUE.

                             {
  Add("150", "200");
  Add("200", "250");
  Add("300", "350");
  Add("400", "450");
  ASSERT_EQ(0, Find("100"));
  ASSERT_EQ(0, Find("150"));
  ASSERT_EQ(0, Find("151"));
  ASSERT_EQ(0, Find("199"));
  ASSERT_EQ(0, Find("200"));
  ASSERT_EQ(1, Find("201"));
  ASSERT_EQ(1, Find("249"));
  ASSERT_EQ(1, Find("250"));
  ASSERT_EQ(2, Find("251"));
  ASSERT_EQ(2, Find("299"));
  ASSERT_EQ(2, Find("300"));
  ASSERT_EQ(2, Find("349"));
  ASSERT_EQ(2, Find("350"));
  ASSERT_EQ(3, Find("351"));
  ASSERT_EQ(3, Find("400"));
  ASSERT_EQ(3, Find("450"));
  ASSERT_EQ(4, Find("451"));

  ASSERT_TRUE(! Overlaps("100", "149"));
  ASSERT_TRUE(! Overlaps("251", "299"));
  ASSERT_TRUE(! Overlaps("451", "500"));
  ASSERT_TRUE(! Overlaps("351", "399"));

  ASSERT_TRUE(Overlaps("100", "150"));
  ASSERT_TRUE(Overlaps("100", "200"));
  ASSERT_TRUE(Overlaps("100", "300"));
  ASSERT_TRUE(Overlaps("100", "400"));
  ASSERT_TRUE(Overlaps("100", "500"));
  ASSERT_TRUE(Overlaps("375", "400"));
  ASSERT_TRUE(Overlaps("450", "450"));
  ASSERT_TRUE(Overlaps("450", "500"));
}

rocksdb::TEST	(	ReduceLevelTest	,
		Last_Level
	)

Definition at line 96 of file reduce_levels_test.cc.

References ASSERT_EQ, ASSERT_OK, and ASSERT_TRUE.

                                  {
  // create files on all levels;
  ASSERT_OK(OpenDB(true, 4, 3));
  ASSERT_OK(Put("aaaa", "11111"));
  ASSERT_OK(CompactMemTable());
  ASSERT_EQ(FilesOnLevel(3), 1);
  CloseDB();

  ASSERT_TRUE(ReduceLevels(3));
  ASSERT_OK(OpenDB(true, 3, 1));
  ASSERT_EQ(FilesOnLevel(2), 1);
  CloseDB();

  ASSERT_TRUE(ReduceLevels(2));
  ASSERT_OK(OpenDB(true, 2, 1));
  ASSERT_EQ(FilesOnLevel(1), 1);
  CloseDB();
}

rocksdb::TEST	(	BloomTest	,
		Small
	)

Definition at line 97 of file bloom_test.cc.

References ASSERT_TRUE.

                       {
  Add("hello");
  Add("world");
  ASSERT_TRUE(Matches("hello"));
  ASSERT_TRUE(Matches("world"));
  ASSERT_TRUE(! Matches("x"));
  ASSERT_TRUE(! Matches("foo"));
}

rocksdb::TEST	(	WriteBatchTest	,
		Corruption
	)

Definition at line 100 of file write_batch_test.cc.

References ASSERT_EQ, rocksdb::WriteBatchInternal::Contents(), rocksdb::Slice::data(), rocksdb::WriteBatch::Delete(), PrintContents(), rocksdb::WriteBatch::Put(), rocksdb::WriteBatchInternal::SetContents(), rocksdb::WriteBatchInternal::SetSequence(), and rocksdb::Slice::size().

                                 {
  WriteBatch batch;
  batch.Put(Slice("foo"), Slice("bar"));
  batch.Delete(Slice("box"));
  WriteBatchInternal::SetSequence(&batch, 200);
  Slice contents = WriteBatchInternal::Contents(&batch);
  WriteBatchInternal::SetContents(&batch,
                                  Slice(contents.data(),contents.size()-1));
  ASSERT_EQ("Put(foo, bar)@200"
            "Corruption: bad WriteBatch Delete",
            PrintContents(&batch));
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		Varint64
	)

Definition at line 103 of file coding_test.cc.

References ASSERT_EQ, ASSERT_TRUE, GetVarint64Ptr(), PutVarint64(), and VarintLength().

                       {
  // Construct the list of values to check
  std::vector<uint64_t> values;
  // Some special values
  values.push_back(0);
  values.push_back(100);
  values.push_back(~static_cast<uint64_t>(0));
  values.push_back(~static_cast<uint64_t>(0) - 1);
  for (uint32_t k = 0; k < 64; k++) {
    // Test values near powers of two
    const uint64_t power = 1ull << k;
    values.push_back(power);
    values.push_back(power-1);
    values.push_back(power+1);
  };

  std::string s;
  for (unsigned int i = 0; i < values.size(); i++) {
    PutVarint64(&s, values[i]);
  }

  const char* p = s.data();
  const char* limit = p + s.size();
  for (unsigned int i = 0; i < values.size(); i++) {
    ASSERT_TRUE(p < limit);
    uint64_t actual;
    const char* start = p;
    p = GetVarint64Ptr(p, limit, &actual);
    ASSERT_TRUE(p != nullptr);
    ASSERT_EQ(values[i], actual);
    ASSERT_EQ(VarintLength(actual), p - start);
  }
  ASSERT_EQ(p, limit);

}

Here is the call graph for this function:

rocksdb::TEST	(	FormatTest	,
		InternalKeyShortestSuccessor
	)

Definition at line 106 of file dbformat_test.cc.

References ASSERT_EQ, IKey(), kMaxSequenceNumber, kTypeValue, kValueTypeForSeek, and ShortSuccessor().

                                               {
  ASSERT_EQ(IKey("g", kMaxSequenceNumber, kValueTypeForSeek),
            ShortSuccessor(IKey("foo", 100, kTypeValue)));
  ASSERT_EQ(IKey("\xff\xff", 100, kTypeValue),
            ShortSuccessor(IKey("\xff\xff", 100, kTypeValue)));
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		HitAndMiss
	)

Definition at line 110 of file cache_test.cc.

References ASSERT_EQ.

                            {
  ASSERT_EQ(-1, Lookup(100));

  Insert(100, 101);
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(-1,  Lookup(200));
  ASSERT_EQ(-1,  Lookup(300));

  Insert(200, 201);
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(-1,  Lookup(300));

  Insert(100, 102);
  ASSERT_EQ(102, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(-1,  Lookup(300));

  ASSERT_EQ(1U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);
}

rocksdb::TEST	(	EnvPosixTest	,
		TwoPools
	)

Definition at line 110 of file env_test.cc.

References ASSERT_LE, rocksdb::Env::Default(), env_, kDelayMicros, mu_, rocksdb::Env::Schedule(), rocksdb::Env::SetBackgroundThreads(), and rocksdb::Env::SleepForMicroseconds().

                             {

  class CB {
   public:
    CB(const std::string& pool_name, int pool_size)
        : mu_(),
          num_running_(0),
          num_finished_(0),
          pool_size_(pool_size),
          pool_name_(pool_name) { }

    static void Run(void* v) {
      CB* cb = reinterpret_cast<CB*>(v);
      cb->Run();
    }

    void Run() {
      {
        MutexLock l(&mu_);
        num_running_++;
        std::cout << "Pool " << pool_name_ << ": "
                  << num_running_ << " running threads.\n";
        // make sure we don't have more than pool_size_ jobs running.
        ASSERT_LE(num_running_, pool_size_);
      }

      // sleep for 1 sec
      Env::Default()->SleepForMicroseconds(1000000);

      {
        MutexLock l(&mu_);
        num_running_--;
        num_finished_++;
      }
    }

    int NumFinished() {
      MutexLock l(&mu_);
      return num_finished_;
    }

   private:
    port::Mutex mu_;
    int num_running_;
    int num_finished_;
    int pool_size_;
    std::string pool_name_;
  };

  const int kLowPoolSize = 2;
  const int kHighPoolSize = 4;
  const int kJobs = 8;

  CB low_pool_job("low", kLowPoolSize);
  CB high_pool_job("high", kHighPoolSize);

  env_->SetBackgroundThreads(kLowPoolSize);
  env_->SetBackgroundThreads(kHighPoolSize, Env::Priority::HIGH);

  // schedule same number of jobs in each pool
  for (int i = 0; i < kJobs; i++) {
    env_->Schedule(&CB::Run, &low_pool_job);
    env_->Schedule(&CB::Run, &high_pool_job, Env::Priority::HIGH);
  }

  // wait for all jobs to finish
  while (low_pool_job.NumFinished() < kJobs ||
         high_pool_job.NumFinished() < kJobs) {
    env_->SleepForMicroseconds(kDelayMicros);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	RedisListsTest	,
		IndexTest
	)

Definition at line 111 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::PushLeft(), and rocksdb::RedisLists::PushRight().

                                {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Empty Index check (return empty and should not crash or edit tempv)
  tempv = "yo";
  ASSERT_TRUE(!redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "yo");
  ASSERT_TRUE(!redis.Index("fda", 3, &tempv));
  ASSERT_EQ(tempv, "yo");
  ASSERT_TRUE(!redis.Index("random", -12391, &tempv));
  ASSERT_EQ(tempv, "yo");

  // Simple Pushes (will yield: [v6, v4, v4, v1, v2, v3]
  redis.PushRight("k1", "v1");
  redis.PushRight("k1", "v2");
  redis.PushRight("k1", "v3");
  redis.PushLeft("k1", "v4");
  redis.PushLeft("k1", "v4");
  redis.PushLeft("k1", "v6");

  // Simple, non-negative indices
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "v6");
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "v4");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "v4");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "v1");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "v2");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "v3");

  // Negative indices
  ASSERT_TRUE(redis.Index("k1", -6, &tempv));
  ASSERT_EQ(tempv, "v6");
  ASSERT_TRUE(redis.Index("k1", -5, &tempv));
  ASSERT_EQ(tempv, "v4");
  ASSERT_TRUE(redis.Index("k1", -4, &tempv));
  ASSERT_EQ(tempv, "v4");
  ASSERT_TRUE(redis.Index("k1", -3, &tempv));
  ASSERT_EQ(tempv, "v1");
  ASSERT_TRUE(redis.Index("k1", -2, &tempv));
  ASSERT_EQ(tempv, "v2");
  ASSERT_TRUE(redis.Index("k1", -1, &tempv));
  ASSERT_EQ(tempv, "v3");

  // Out of bounds (return empty, no crash)
  ASSERT_TRUE(!redis.Index("k1", 6, &tempv));
  ASSERT_TRUE(!redis.Index("k1", 123219, &tempv));
  ASSERT_TRUE(!redis.Index("k1", -7, &tempv));
  ASSERT_TRUE(!redis.Index("k1", -129, &tempv));
}

Here is the call graph for this function:

rocksdb::TEST	(	WriteBatchTest	,
		Append
	)

Definition at line 113 of file write_batch_test.cc.

References rocksdb::WriteBatchInternal::Append(), ASSERT_EQ, rocksdb::WriteBatch::Clear(), rocksdb::WriteBatch::Count(), rocksdb::WriteBatch::Delete(), PrintContents(), rocksdb::WriteBatch::Put(), and rocksdb::WriteBatchInternal::SetSequence().

                             {
  WriteBatch b1, b2;
  WriteBatchInternal::SetSequence(&b1, 200);
  WriteBatchInternal::SetSequence(&b2, 300);
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("",
            PrintContents(&b1));
  ASSERT_EQ(0, b1.Count());
  b2.Put("a", "va");
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("Put(a, va)@200",
            PrintContents(&b1));
  ASSERT_EQ(1, b1.Count());
  b2.Clear();
  b2.Put("b", "vb");
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("Put(a, va)@200"
            "Put(b, vb)@201",
            PrintContents(&b1));
  ASSERT_EQ(2, b1.Count());
  b2.Delete("foo");
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("Put(a, va)@200"
            "Put(b, vb)@202"
            "Put(b, vb)@201"
            "Delete(foo)@203",
            PrintContents(&b1));
  ASSERT_EQ(4, b1.Count());
}

Here is the call graph for this function:

rocksdb::TEST	(	ReduceLevelTest	,
		Top_Level
	)

Definition at line 115 of file reduce_levels_test.cc.

References ASSERT_EQ, ASSERT_OK, and ASSERT_TRUE.

                                 {
  // create files on all levels;
  ASSERT_OK(OpenDB(true, 5, 0));
  ASSERT_OK(Put("aaaa", "11111"));
  ASSERT_OK(CompactMemTable());
  ASSERT_EQ(FilesOnLevel(0), 1);
  CloseDB();

  ASSERT_TRUE(ReduceLevels(4));
  ASSERT_OK(OpenDB(true, 4, 0));
  CloseDB();

  ASSERT_TRUE(ReduceLevels(3));
  ASSERT_OK(OpenDB(true, 3, 0));
  CloseDB();

  ASSERT_TRUE(ReduceLevels(2));
  ASSERT_OK(OpenDB(true, 2, 0));
  CloseDB();
}

rocksdb::TEST	(	BloomTest	,
		VaryingLengths
	)

Definition at line 119 of file bloom_test.cc.

References ASSERT_LE, ASSERT_TRUE, kVerbose, and NextLength().

                                {
  char buffer[sizeof(int)];

  // Count number of filters that significantly exceed the false positive rate
  int mediocre_filters = 0;
  int good_filters = 0;

  for (int length = 1; length <= 10000; length = NextLength(length)) {
    Reset();
    for (int i = 0; i < length; i++) {
      Add(Key(i, buffer));
    }
    Build();

    ASSERT_LE(FilterSize(), (size_t)((length * 10 / 8) + 40)) << length;

    // All added keys must match
    for (int i = 0; i < length; i++) {
      ASSERT_TRUE(Matches(Key(i, buffer)))
          << "Length " << length << "; key " << i;
    }

    // Check false positive rate
    double rate = FalsePositiveRate();
    if (kVerbose >= 1) {
      fprintf(stderr, "False positives: %5.2f%% @ length = %6d ; bytes = %6d\n",
              rate*100.0, length, static_cast<int>(FilterSize()));
    }
    ASSERT_LE(rate, 0.02);   // Must not be over 2%
    if (rate > 0.0125) mediocre_filters++;  // Allowed, but not too often
    else good_filters++;
  }
  if (kVerbose >= 1) {
    fprintf(stderr, "Filters: %d good, %d mediocre\n",
            good_filters, mediocre_filters);
  }
  ASSERT_LE(mediocre_filters, good_filters/5);
}

Here is the call graph for this function:

rocksdb::TEST	(	AutoRollLoggerTest	,
		RollLogFileBySize
	)

Definition at line 126 of file auto_roll_logger_test.cc.

References logger.

                                            {
    InitTestDb();
    size_t log_max_size = 1024 * 5;

    AutoRollLogger logger(Env::Default(), kTestDir, "", log_max_size, 0);

    RollLogFileBySizeTest(&logger, log_max_size,
                          kSampleMessage + ":RollLogFileBySize");

}

rocksdb::TEST	(	StringAppendOperatorTest	,
		IteratorTest
	)

Definition at line 129 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, db_, beast.util.Iter::first(), rocksdb::DBImpl::NewIterator(), and OpenDb().

                                             {
  auto db_ = OpenDb(',');
  StringLists slists(db_);

  slists.Append("k1", "v1");
  slists.Append("k1", "v2");
  slists.Append("k1", "v3");

  slists.Append("k2", "a1");
  slists.Append("k2", "a2");
  slists.Append("k2", "a3");

  std::string res;
  std::unique_ptr<rocksdb::Iterator> it(db_->NewIterator(ReadOptions()));
  std::string k1("k1");
  std::string k2("k2");
  bool first = true;
  for (it->Seek(k1); it->Valid(); it->Next()) {
    res = it->value().ToString();
    if (first) {
      ASSERT_EQ(res, "v1,v2,v3");
      first = false;
    } else {
      ASSERT_EQ(res, "a1,a2,a3");
    }
  }
  slists.Append("k2", "a4");
  slists.Append("k1", "v4");

  // Snapshot should still be the same. Should ignore a4 and v4.
  first = true;
  for (it->Seek(k1); it->Valid(); it->Next()) {
    res = it->value().ToString();
    if (first) {
      ASSERT_EQ(res, "v1,v2,v3");
      first = false;
    } else {
      ASSERT_EQ(res, "a1,a2,a3");
    }
  }


  // Should release the snapshot and be aware of the new stuff now
  it.reset(db_->NewIterator(ReadOptions()));
  first = true;
  for (it->Seek(k1); it->Valid(); it->Next()) {
    res = it->value().ToString();
    if (first) {
      ASSERT_EQ(res, "v1,v2,v3,v4");
      first = false;
    } else {
      ASSERT_EQ(res, "a1,a2,a3,a4");
    }
  }

  // start from k2 this time.
  for (it->Seek(k2); it->Valid(); it->Next()) {
    res = it->value().ToString();
    if (first) {
      ASSERT_EQ(res, "v1,v2,v3,v4");
      first = false;
    } else {
      ASSERT_EQ(res, "a1,a2,a3,a4");
    }
  }

  slists.Append("k3", "g1");

  it.reset(db_->NewIterator(ReadOptions()));
  first = true;
  std::string k3("k3");
  for(it->Seek(k2); it->Valid(); it->Next()) {
    res = it->value().ToString();
    if (first) {
      ASSERT_EQ(res, "a1,a2,a3,a4");
      first = false;
    } else {
      ASSERT_EQ(res, "g1");
    }
  }
  for(it->Seek(k3); it->Valid(); it->Next()) {
    res = it->value().ToString();
    if (first) {
      // should not be hit
      ASSERT_EQ(res, "a1,a2,a3,a4");
      first = false;
    } else {
      ASSERT_EQ(res, "g1");
    }
  }

}

Here is the call graph for this function:

rocksdb::TEST	(	PerfContextTest	,
		StopWatchNanoOverhead
	)

Definition at line 129 of file perf_context_test.cc.

References rocksdb::HistogramImpl::Add(), rocksdb::Env::Default(), rocksdb::StopWatchNano::ElapsedNanos(), and rocksdb::HistogramImpl::ToString().

                                             {
  // profile the timer cost by itself!
  const int kTotalIterations = 1000000;
  std::vector<uint64_t> timings(kTotalIterations);

  StopWatchNano timer(Env::Default(), true);
  for (auto& timing : timings) {
    timing = timer.ElapsedNanos(true /* reset */);
  }

  HistogramImpl histogram;
  for (const auto timing : timings) {
    histogram.Add(timing);
  }

  std::cout << histogram.ToString();
}

Here is the call graph for this function:

rocksdb::TEST	(	MemEnvTest	,
		Locks
	)

Definition at line 131 of file memenv_test.cc.

References ASSERT_OK, env_, rocksdb::Env::LockFile(), and rocksdb::Env::UnlockFile().

                        {
  FileLock* lock;

  // These are no-ops, but we test they return success.
  ASSERT_OK(env_->LockFile("some file", &lock));
  ASSERT_OK(env_->UnlockFile(lock));
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		Erase
	)

Definition at line 133 of file cache_test.cc.

References ASSERT_EQ.

                       {
  Erase(200);
  ASSERT_EQ(0U, deleted_keys_.size());

  Insert(100, 101);
  Insert(200, 201);
  Erase(100);
  ASSERT_EQ(-1,  Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(1U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);

  Erase(100);
  ASSERT_EQ(-1,  Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(1U, deleted_keys_.size());
}

rocksdb::TEST	(	PrefixTest	,
		DynamicPrefixIterator
	)

Definition at line 133 of file prefix_test.cc.

References rocksdb::HistogramImpl::Add(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db, rocksdb::Env::Default(), rocksdb::DBImpl::Delete(), DestroyDB(), rocksdb::StopWatchNano::ElapsedNanos(), kDbName, rocksdb::DBImpl::NewIterator(), OpenDb(), perf_context, rocksdb::TestKey::prefix, std::chrono::prefix, rocksdb::ReadOptions::prefix_seek, rocksdb::DBImpl::Put(), rocksdb::PerfContext::Reset(), SliceToTestKey(), TestKeyToSlice(), beast::IP::to_string(), rocksdb::HistogramImpl::ToString(), rocksdb::PerfContext::user_key_comparison_count, and value.

                                        {

  DestroyDB(kDbName, Options());
  auto db = OpenDb();
  WriteOptions write_options;
  ReadOptions read_options;

  std::vector<uint64_t> prefixes;
  for (uint64_t i = 0; i < FLAGS_total_prefixes; ++i) {
    prefixes.push_back(i);
  }

  if (FLAGS_random_prefix) {
    std::random_shuffle(prefixes.begin(), prefixes.end());
  }

  // insert x random prefix, each with y continuous element.
  for (auto prefix : prefixes) {
     for (uint64_t sorted = 0; sorted < FLAGS_items_per_prefix; sorted++) {
      TestKey test_key(prefix, sorted);

      Slice key = TestKeyToSlice(test_key);
      std::string value = "v" + std::to_string(sorted);

      ASSERT_OK(db->Put(write_options, key, value));
    }
  }

  // test seek existing keys
  HistogramImpl hist_seek_time;
  HistogramImpl hist_seek_comparison;

  if (FLAGS_use_prefix_hash_memtable) {
    read_options.prefix_seek = true;
  }
  std::unique_ptr<Iterator> iter(db->NewIterator(read_options));

  for (auto prefix : prefixes) {
    TestKey test_key(prefix, FLAGS_items_per_prefix / 2);
    Slice key = TestKeyToSlice(test_key);
    std::string value = "v" + std::to_string(0);

    perf_context.Reset();
    StopWatchNano timer(Env::Default(), true);
    uint64_t total_keys = 0;
    for (iter->Seek(key); iter->Valid(); iter->Next()) {
      if (FLAGS_trigger_deadlock) {
        std::cout << "Behold the deadlock!\n";
        db->Delete(write_options, iter->key());
      }
      auto test_key = SliceToTestKey(iter->key());
      if (test_key->prefix != prefix) break;
      total_keys++;
    }
    hist_seek_time.Add(timer.ElapsedNanos());
    hist_seek_comparison.Add(perf_context.user_key_comparison_count);
    ASSERT_EQ(total_keys, FLAGS_items_per_prefix - FLAGS_items_per_prefix/2);
  }

  std::cout << "Seek key comparison: \n"
            << hist_seek_comparison.ToString()
            << "Seek time: \n"
            << hist_seek_time.ToString();

  // test non-existing keys
  HistogramImpl hist_no_seek_time;
  HistogramImpl hist_no_seek_comparison;

  for (auto prefix = FLAGS_total_prefixes;
       prefix < FLAGS_total_prefixes + 100;
       prefix++) {
    TestKey test_key(prefix, 0);
    Slice key = TestKeyToSlice(test_key);

    perf_context.Reset();
    StopWatchNano timer(Env::Default(), true);
    iter->Seek(key);
    hist_no_seek_time.Add(timer.ElapsedNanos());
    hist_no_seek_comparison.Add(perf_context.user_key_comparison_count);
    ASSERT_TRUE(!iter->Valid());
  }

  std::cout << "non-existing Seek key comparison: \n"
            << hist_no_seek_comparison.ToString()
            << "non-existing Seek time: \n"
            << hist_no_seek_time.ToString();
}

Here is the call graph for this function:

rocksdb::TEST	(	FindFileTest	,
		MultipleNullBoundaries
	)

Definition at line 133 of file version_set_test.cc.

References ASSERT_TRUE.

                                           {
  Add("150", "200");
  Add("200", "250");
  Add("300", "350");
  Add("400", "450");
  ASSERT_TRUE(! Overlaps(nullptr, "149"));
  ASSERT_TRUE(! Overlaps("451", nullptr));
  ASSERT_TRUE(Overlaps(nullptr, nullptr));
  ASSERT_TRUE(Overlaps(nullptr, "150"));
  ASSERT_TRUE(Overlaps(nullptr, "199"));
  ASSERT_TRUE(Overlaps(nullptr, "200"));
  ASSERT_TRUE(Overlaps(nullptr, "201"));
  ASSERT_TRUE(Overlaps(nullptr, "400"));
  ASSERT_TRUE(Overlaps(nullptr, "800"));
  ASSERT_TRUE(Overlaps("100", nullptr));
  ASSERT_TRUE(Overlaps("200", nullptr));
  ASSERT_TRUE(Overlaps("449", nullptr));
  ASSERT_TRUE(Overlaps("450", nullptr));
}

rocksdb::TEST	(	BlobStoreTest	,
		CreateAndStoreTest
	)

Definition at line 134 of file blob_store_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Env::Default(), rocksdb::BlobStore::Delete(), rocksdb::BlobStore::Get(), rocksdb::BlobStore::Put(), rand, rocksdb::test::RandomString(), rocksdb::BlobStore::Sync(), and rocksdb::test::TmpDir().

                                        {
  const uint64_t block_size = 10;
  const uint32_t blocks_per_file = 1000;
  const int max_blurb_size = 300;
  Random random(5);

  BlobStore blob_store(test::TmpDir() + "/blob_store_test",
                       block_size,
                       blocks_per_file,
                       10000,
                       Env::Default());
  vector<pair<Blob, string>> ranges;

  for (int i = 0; i < 2000; ++i) {
    int decision = rand() % 5;
    if (decision <= 2 || ranges.size() == 0) {
      string buf;
      int size_blocks = (rand() % max_blurb_size + 1);
      int string_size = size_blocks * block_size - (rand() % block_size);
      test::RandomString(&random, string_size, &buf);
      Blob r;
      ASSERT_OK(blob_store.Put(Slice(buf), &r));
      ranges.push_back(make_pair(r, buf));
    } else if (decision == 3) {
      int ti = rand() % ranges.size();
      string out_buf;
      ASSERT_OK(blob_store.Get(ranges[ti].first, &out_buf));
      ASSERT_EQ(ranges[ti].second, out_buf);
    } else {
      int ti = rand() % ranges.size();
      ASSERT_OK(blob_store.Delete(ranges[ti].first));
      ranges.erase(ranges.begin() + ti);
    }
  }
  ASSERT_OK(blob_store.Sync());
}

Here is the call graph for this function:

rocksdb::TEST	(	ReduceLevelTest	,
		All_Levels
	)

Definition at line 136 of file reduce_levels_test.cc.

References ASSERT_EQ, ASSERT_OK, and ASSERT_TRUE.

                                  {
  // create files on all levels;
  ASSERT_OK(OpenDB(true, 5, 1));
  ASSERT_OK(Put("a", "a11111"));
  ASSERT_OK(CompactMemTable());
  ASSERT_EQ(FilesOnLevel(1), 1);
  CloseDB();

  ASSERT_OK(OpenDB(true, 5, 2));
  ASSERT_OK(Put("b", "b11111"));
  ASSERT_OK(CompactMemTable());
  ASSERT_EQ(FilesOnLevel(1), 1);
  ASSERT_EQ(FilesOnLevel(2), 1);
  CloseDB();

  ASSERT_OK(OpenDB(true, 5, 3));
  ASSERT_OK(Put("c", "c11111"));
  ASSERT_OK(CompactMemTable());
  ASSERT_EQ(FilesOnLevel(1), 1);
  ASSERT_EQ(FilesOnLevel(2), 1);
  ASSERT_EQ(FilesOnLevel(3), 1);
  CloseDB();

  ASSERT_OK(OpenDB(true, 5, 4));
  ASSERT_OK(Put("d", "d11111"));
  ASSERT_OK(CompactMemTable());
  ASSERT_EQ(FilesOnLevel(1), 1);
  ASSERT_EQ(FilesOnLevel(2), 1);
  ASSERT_EQ(FilesOnLevel(3), 1);
  ASSERT_EQ(FilesOnLevel(4), 1);
  CloseDB();

  ASSERT_TRUE(ReduceLevels(4));
  ASSERT_OK(OpenDB(true, 4, 0));
  ASSERT_EQ("a11111", Get("a"));
  ASSERT_EQ("b11111", Get("b"));
  ASSERT_EQ("c11111", Get("c"));
  ASSERT_EQ("d11111", Get("d"));
  CloseDB();

  ASSERT_TRUE(ReduceLevels(3));
  ASSERT_OK(OpenDB(true, 3, 0));
  ASSERT_EQ("a11111", Get("a"));
  ASSERT_EQ("b11111", Get("b"));
  ASSERT_EQ("c11111", Get("c"));
  ASSERT_EQ("d11111", Get("d"));
  CloseDB();

  ASSERT_TRUE(ReduceLevels(2));
  ASSERT_OK(OpenDB(true, 2, 0));
  ASSERT_EQ("a11111", Get("a"));
  ASSERT_EQ("b11111", Get("b"));
  ASSERT_EQ("c11111", Get("c"));
  ASSERT_EQ("d11111", Get("d"));
  CloseDB();
}

rocksdb::TEST	(	AutoRollLoggerTest	,
		RollLogFileByTime
	)

Definition at line 137 of file auto_roll_logger_test.cc.

References ASSERT_TRUE, env, kLogFile, and logger.

                                            {
    size_t time = 1;
    size_t log_size = 1024 * 5;

    InitTestDb();
    // -- Test the existence of file during the server restart.
    ASSERT_TRUE(!env->FileExists(kLogFile));
    AutoRollLogger logger(Env::Default(), kTestDir, "", log_size, 1);
    ASSERT_TRUE(env->FileExists(kLogFile));

    RollLogFileByTimeTest(&logger, time, kSampleMessage + ":RollLogFileByTime");
}

rocksdb::TEST	(	Coding	,
		Varint32Overflow
	)

Definition at line 139 of file coding_test.cc.

References ASSERT_TRUE, and GetVarint32Ptr().

                               {
  uint32_t result;
  std::string input("\x81\x82\x83\x84\x85\x11");
  ASSERT_TRUE(GetVarint32Ptr(input.data(), input.data() + input.size(), &result)
              == nullptr);
}

Here is the call graph for this function:

rocksdb::TEST	(	MemEnvTest	,
		Misc
	)

Definition at line 139 of file memenv_test.cc.

References ASSERT_OK, ASSERT_TRUE, env_, rocksdb::Env::GetTestDirectory(), rocksdb::Env::NewWritableFile(), and soptions_.

                       {
  std::string test_dir;
  ASSERT_OK(env_->GetTestDirectory(&test_dir));
  ASSERT_TRUE(!test_dir.empty());

  unique_ptr<WritableFile> writable_file;
  ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file, soptions_));

  // These are no-ops, but we test they return success.
  ASSERT_OK(writable_file->Sync());
  ASSERT_OK(writable_file->Flush());
  ASSERT_OK(writable_file->Close());
  writable_file.reset();
}

Here is the call graph for this function:

rocksdb::TEST	(	TablePropertiesTest	,
		CustomizedTablePropertiesCollector
	)

Definition at line 145 of file table_properties_collector_test.cc.

References rocksdb::TableBuilder::Add(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::FakeWritableFile::contents(), rocksdb::InternalKey::Encode(), rocksdb::TableBuilder::Finish(), GetVarint32(), kTypeValue, MakeBuilder(), OpenTable(), and rocksdb::Options::table_properties_collectors.

                                                              {
  Options options;

  // make sure the entries will be inserted with order.
  std::map<std::string, std::string> kvs = {
    {"About",     "val5"},  // starts with 'A'
    {"Abstract",  "val2"},  // starts with 'A'
    {"Around",    "val7"},  // starts with 'A'
    {"Beyond",    "val3"},
    {"Builder",   "val1"},
    {"Cancel",    "val4"},
    {"Find",      "val6"},
  };

  // Test properties collectors with internal keys or regular keys
  for (bool encode_as_internal : { true, false }) {
    // -- Step 1: build table
    auto collector = new RegularKeysStartWithA();
    if (encode_as_internal) {
      options.table_properties_collectors = {
        std::make_shared<UserKeyTablePropertiesCollector>(collector)
      };
    } else {
      options.table_properties_collectors.resize(1);
      options.table_properties_collectors[0].reset(collector);
    }
    std::unique_ptr<TableBuilder> builder;
    std::unique_ptr<FakeWritableFile> writable;
    MakeBuilder(options, &writable, &builder);

    for (const auto& kv : kvs) {
      if (encode_as_internal) {
        InternalKey ikey(kv.first, 0, ValueType::kTypeValue);
        builder->Add(ikey.Encode(), kv.second);
      } else {
        builder->Add(kv.first, kv.second);
      }
    }
    ASSERT_OK(builder->Finish());

    // -- Step 2: Open table
    std::unique_ptr<TableReader> table_reader;
    OpenTable(options, writable->contents(), &table_reader);
    const auto& properties =
      table_reader->GetTableProperties().user_collected_properties;

    ASSERT_EQ("Rocksdb", properties.at("TablePropertiesTest"));

    uint32_t starts_with_A = 0;
    Slice key(properties.at("Count"));
    ASSERT_TRUE(GetVarint32(&key, &starts_with_A));
    ASSERT_EQ(3u, starts_with_A);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		Varint32Truncation
	)

Definition at line 146 of file coding_test.cc.

References ASSERT_EQ, ASSERT_TRUE, GetVarint32Ptr(), and PutVarint32().

                                 {
  uint32_t large_value = (1u << 31) + 100;
  std::string s;
  PutVarint32(&s, large_value);
  uint32_t result;
  for (unsigned int len = 0; len < s.size() - 1; len++) {
    ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + len, &result) == nullptr);
  }
  ASSERT_TRUE(
      GetVarint32Ptr(s.data(), s.data() + s.size(), &result) != nullptr);
  ASSERT_EQ(large_value, result);
}

Here is the call graph for this function:

rocksdb::TEST	(	DeleteFileTest	,
		AddKeysAndQueryLevels
	)

Definition at line 147 of file deletefile_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db_, rocksdb::DBImpl::DeleteFile(), rocksdb::DBImpl::GetLiveFilesMetaData(), and rocksdb::Status::IsInvalidArgument().

                                            {
  CreateTwoLevels();
  std::vector<LiveFileMetaData> metadata;
  std::vector<int> keysinlevel;
  db_->GetLiveFilesMetaData(&metadata);

  std::string level1file = "";
  int level1keycount = 0;
  std::string level2file = "";
  int level2keycount = 0;
  int level1index = 0;
  int level2index = 1;

  ASSERT_EQ((int)metadata.size(), 2);
  if (metadata[0].level == 2) {
    level1index = 1;
    level2index = 0;
  }

  level1file = metadata[level1index].name;
  int startkey = atoi(metadata[level1index].smallestkey.c_str());
  int endkey = atoi(metadata[level1index].largestkey.c_str());
  level1keycount = (endkey - startkey + 1);
  level2file = metadata[level2index].name;
  startkey = atoi(metadata[level2index].smallestkey.c_str());
  endkey = atoi(metadata[level2index].largestkey.c_str());
  level2keycount = (endkey - startkey + 1);

  // COntrolled setup. Levels 1 and 2 should both have 50K files.
  // This is a little fragile as it depends on the current
  // compaction heuristics.
  ASSERT_EQ(level1keycount, 50000);
  ASSERT_EQ(level2keycount, 50000);

  Status status = db_->DeleteFile("0.sst");
  ASSERT_TRUE(status.IsInvalidArgument());

  // intermediate level files cannot be deleted.
  status = db_->DeleteFile(level1file);
  ASSERT_TRUE(status.IsInvalidArgument());

  // Lowest level file deletion should succeed.
  ASSERT_OK(db_->DeleteFile(level2file));

  CloseDB();
}

Here is the call graph for this function:

rocksdb::TEST	(	PerfContextTest	,
		StopWatchOverhead
	)

Definition at line 147 of file perf_context_test.cc.

References rocksdb::HistogramImpl::Add(), rocksdb::Env::Default(), rocksdb::StopWatch::ElapsedMicros(), and rocksdb::HistogramImpl::ToString().

                                         {
  // profile the timer cost by itself!
  const int kTotalIterations = 1000000;
  std::vector<uint64_t> timings(kTotalIterations);

  StopWatch timer(Env::Default());
  for (auto& timing : timings) {
    timing = timer.ElapsedMicros();
  }

  HistogramImpl histogram;
  uint64_t prev_timing = 0;
  for (const auto timing : timings) {
    histogram.Add(timing - prev_timing);
    prev_timing = timing;
  }

  std::cout << histogram.ToString();
}

Here is the call graph for this function:

rocksdb::TEST	(	AutoRollLoggerTest	,
		OpenLogFilesMultipleTimesWithOptionLog_max_size
	)

Definition at line 150 of file auto_roll_logger_test.cc.

References ASSERT_EQ, ASSERT_GT, rocksdb::AutoRollLogger::GetLogFileSize(), logger, and LogMessage().

                                                      {
  // If only 'log_max_size' options is specified, then every time
  // when rocksdb is restarted, a new empty log file will be created.
  InitTestDb();
  // WORKAROUND:
  // avoid complier's complaint of "comparison between signed
  // and unsigned integer expressions" because literal 0 is
  // treated as "singed".
  size_t kZero = 0;
  size_t log_size = 1024;

  AutoRollLogger* logger = new AutoRollLogger(
    Env::Default(), kTestDir, "", log_size, 0);

  LogMessage(logger, kSampleMessage.c_str());
  ASSERT_GT(logger->GetLogFileSize(), kZero);
  delete logger;

  // reopens the log file and an empty log file will be created.
  logger = new AutoRollLogger(
    Env::Default(), kTestDir, "", log_size, 0);
  ASSERT_EQ(logger->GetLogFileSize(), kZero);
  delete logger;
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		EntriesArePinned
	)

Definition at line 152 of file cache_test.cc.

References ASSERT_EQ, DecodeValue(), and EncodeKey().

                                  {
  Insert(100, 101);
  Cache::Handle* h1 = cache_->Lookup(EncodeKey(100));
  ASSERT_EQ(101, DecodeValue(cache_->Value(h1)));

  Insert(100, 102);
  Cache::Handle* h2 = cache_->Lookup(EncodeKey(100));
  ASSERT_EQ(102, DecodeValue(cache_->Value(h2)));
  ASSERT_EQ(0U, deleted_keys_.size());

  cache_->Release(h1);
  ASSERT_EQ(1U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);

  Erase(100);
  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(1U, deleted_keys_.size());

  cache_->Release(h2);
  ASSERT_EQ(2U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[1]);
  ASSERT_EQ(102, deleted_values_[1]);
}

Here is the call graph for this function:

rocksdb::TEST	(	FindFileTest	,
		OverlapSequenceChecks
	)

Definition at line 153 of file version_set_test.cc.

References ASSERT_TRUE.

                                          {
  Add("200", "200", 5000, 3000);
  ASSERT_TRUE(! Overlaps("199", "199"));
  ASSERT_TRUE(! Overlaps("201", "300"));
  ASSERT_TRUE(Overlaps("200", "200"));
  ASSERT_TRUE(Overlaps("190", "200"));
  ASSERT_TRUE(Overlaps("200", "210"));
}

rocksdb::TEST	(	MemEnvTest	,
		LargeWrite
	)

Definition at line 154 of file memenv_test.cc.

References rocksdb::WritableFile::Append(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::Slice::compare(), rocksdb::Slice::data(), env_, rocksdb::Env::NewSequentialFile(), rocksdb::Env::NewWritableFile(), beast::asio::InputParser::read(), rocksdb::SequentialFile::Read(), rocksdb::Slice::size(), and soptions_.

                             {
  const size_t kWriteSize = 300 * 1024;
  char* scratch = new char[kWriteSize * 2];

  std::string write_data;
  for (size_t i = 0; i < kWriteSize; ++i) {
    write_data.append(1, static_cast<char>(i));
  }

  unique_ptr<WritableFile> writable_file;
  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
  ASSERT_OK(writable_file->Append("foo"));
  ASSERT_OK(writable_file->Append(write_data));
  writable_file.reset();

  unique_ptr<SequentialFile> seq_file;
  Slice result;
  ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file, soptions_));
  ASSERT_OK(seq_file->Read(3, &result, scratch)); // Read "foo".
  ASSERT_EQ(0, result.compare("foo"));

  size_t read = 0;
  std::string read_data;
  while (read < kWriteSize) {
    ASSERT_OK(seq_file->Read(kWriteSize - read, &result, scratch));
    read_data.append(result.data(), result.size());
    read += result.size();
  }
  ASSERT_TRUE(write_data == read_data);
  delete [] scratch;
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		Varint64Overflow
	)

Definition at line 159 of file coding_test.cc.

References ASSERT_TRUE, and GetVarint64Ptr().

                               {
  uint64_t result;
  std::string input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11");
  ASSERT_TRUE(GetVarint64Ptr(input.data(), input.data() + input.size(), &result)
              == nullptr);
}

Here is the call graph for this function:

rocksdb::TEST	(	WriteBatchTest	,
		Blob
	)

Definition at line 161 of file write_batch_test.cc.

References ASSERT_EQ, rocksdb::WriteBatch::Count(), rocksdb::WriteBatch::Delete(), rocksdb::WriteBatch::Iterate(), rocksdb::WriteBatch::Merge(), PrintContents(), rocksdb::WriteBatch::Put(), and rocksdb::WriteBatch::PutLogData().

                           {
  WriteBatch batch;
  batch.Put(Slice("k1"), Slice("v1"));
  batch.Put(Slice("k2"), Slice("v2"));
  batch.Put(Slice("k3"), Slice("v3"));
  batch.PutLogData(Slice("blob1"));
  batch.Delete(Slice("k2"));
  batch.PutLogData(Slice("blob2"));
  batch.Merge(Slice("foo"), Slice("bar"));
  ASSERT_EQ(5, batch.Count());
  ASSERT_EQ("Merge(foo, bar)@4"
            "Put(k1, v1)@0"
            "Delete(k2)@3"
            "Put(k2, v2)@1"
            "Put(k3, v3)@2",
            PrintContents(&batch));

  TestHandler handler;
  batch.Iterate(&handler);
  ASSERT_EQ(
            "Put(k1, v1)"
            "Put(k2, v2)"
            "Put(k3, v3)"
            "LogData(blob1)"
            "Delete(k2)"
            "LogData(blob2)"
            "Merge(foo, bar)",
            handler.seen);
}

Here is the call graph for this function:

rocksdb::TEST	(	FindFileTest	,
		OverlappingFiles
	)

Definition at line 162 of file version_set_test.cc.

References ASSERT_TRUE.

                                     {
  Add("150", "600");
  Add("400", "500");
  disjoint_sorted_files_ = false;
  ASSERT_TRUE(! Overlaps("100", "149"));
  ASSERT_TRUE(! Overlaps("601", "700"));
  ASSERT_TRUE(Overlaps("100", "150"));
  ASSERT_TRUE(Overlaps("100", "200"));
  ASSERT_TRUE(Overlaps("100", "300"));
  ASSERT_TRUE(Overlaps("100", "400"));
  ASSERT_TRUE(Overlaps("100", "500"));
  ASSERT_TRUE(Overlaps("375", "400"));
  ASSERT_TRUE(Overlaps("450", "450"));
  ASSERT_TRUE(Overlaps("450", "500"));
  ASSERT_TRUE(Overlaps("450", "700"));
  ASSERT_TRUE(Overlaps("600", "700"));
}

rocksdb::TEST	(	Coding	,
		Varint64Truncation
	)

Definition at line 166 of file coding_test.cc.

References ASSERT_EQ, ASSERT_TRUE, GetVarint64Ptr(), and PutVarint64().

                                 {
  uint64_t large_value = (1ull << 63) + 100ull;
  std::string s;
  PutVarint64(&s, large_value);
  uint64_t result;
  for (unsigned int len = 0; len < s.size() - 1; len++) {
    ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + len, &result) == nullptr);
  }
  ASSERT_TRUE(
      GetVarint64Ptr(s.data(), s.data() + s.size(), &result) != nullptr);
  ASSERT_EQ(large_value, result);
}

Here is the call graph for this function:

rocksdb::TEST	(	RedisListsTest	,
		RangeTest
	)

Definition at line 170 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PushLeft(), rocksdb::RedisLists::PushRight(), and rocksdb::RedisLists::Range().

                                {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Simple Pushes (will yield: [v6, v4, v4, v1, v2, v3])
  redis.PushRight("k1", "v1");
  redis.PushRight("k1", "v2");
  redis.PushRight("k1", "v3");
  redis.PushLeft("k1", "v4");
  redis.PushLeft("k1", "v4");
  redis.PushLeft("k1", "v6");

  // Sanity check (check the length;  make sure it's 6)
  ASSERT_EQ(redis.Length("k1"), 6);

  // Simple range
  std::vector<std::string> res = redis.Range("k1", 1, 4);
  ASSERT_EQ((int)res.size(), 4);
  ASSERT_EQ(res[0], "v4");
  ASSERT_EQ(res[1], "v4");
  ASSERT_EQ(res[2], "v1");
  ASSERT_EQ(res[3], "v2");

  // Negative indices (i.e.: measured from the end)
  res = redis.Range("k1", 2, -1);
  ASSERT_EQ((int)res.size(), 4);
  ASSERT_EQ(res[0], "v4");
  ASSERT_EQ(res[1], "v1");
  ASSERT_EQ(res[2], "v2");
  ASSERT_EQ(res[3], "v3");

  res = redis.Range("k1", -6, -4);
  ASSERT_EQ((int)res.size(), 3);
  ASSERT_EQ(res[0], "v6");
  ASSERT_EQ(res[1], "v4");
  ASSERT_EQ(res[2], "v4");

  res = redis.Range("k1", -1, 5);
  ASSERT_EQ((int)res.size(), 1);
  ASSERT_EQ(res[0], "v3");

  // Partial / Broken indices
  res = redis.Range("k1", -3, 1000000);
  ASSERT_EQ((int)res.size(), 3);
  ASSERT_EQ(res[0], "v1");
  ASSERT_EQ(res[1], "v2");
  ASSERT_EQ(res[2], "v3");

  res = redis.Range("k1", -1000000, 1);
  ASSERT_EQ((int)res.size(), 2);
  ASSERT_EQ(res[0], "v6");
  ASSERT_EQ(res[1], "v4");

  // Invalid indices
  res = redis.Range("k1", 7, 9);
  ASSERT_EQ((int)res.size(), 0);

  res = redis.Range("k1", -8, -7);
  ASSERT_EQ((int)res.size(), 0);

  res = redis.Range("k1", 3, 2);
  ASSERT_EQ((int)res.size(), 0);

  res = redis.Range("k1", 5, -2);
  ASSERT_EQ((int)res.size(), 0);

  // Range matches Index
  res = redis.Range("k1", -6, -4);
  ASSERT_TRUE(redis.Index("k1", -6, &tempv));
  ASSERT_EQ(tempv, res[0]);
  ASSERT_TRUE(redis.Index("k1", -5, &tempv));
  ASSERT_EQ(tempv, res[1]);
  ASSERT_TRUE(redis.Index("k1", -4, &tempv));
  ASSERT_EQ(tempv, res[2]);

  // Last check
  res = redis.Range("k1", 0, -6);
  ASSERT_EQ((int)res.size(), 1);
  ASSERT_EQ(res[0], "v6");
}

Here is the call graph for this function:

rocksdb::TEST	(	BlobStoreTest	,
		MaxSizeTest
	)

Definition at line 171 of file blob_store_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Env::Default(), rocksdb::Status::ok(), rocksdb::BlobStore::Put(), rocksdb::test::RandomString(), and rocksdb::test::TmpDir().

                                 {
  const uint64_t block_size = 10;
  const uint32_t blocks_per_file = 100;
  const int max_buckets = 10;
  Random random(5);

  BlobStore blob_store(test::TmpDir() + "/blob_store_test",
                       block_size,
                       blocks_per_file,
                       max_buckets,
                       Env::Default());
  string buf;
  for (int i = 0; i < max_buckets; ++i) {
    test::RandomString(&random, 1000, &buf);
    Blob r;
    ASSERT_OK(blob_store.Put(Slice(buf), &r));
  }

  test::RandomString(&random, 1000, &buf);
  Blob r;
  // should fail because max size
  Status s = blob_store.Put(Slice(buf), &r);
  ASSERT_EQ(s.ok(), false);
}

Here is the call graph for this function:

rocksdb::TEST	(	AutoRollLoggerTest	,
		CompositeRollByTimeAndSizeLogger
	)

Definition at line 176 of file auto_roll_logger_test.cc.

References logger.

                                                           {
  size_t time = 1, log_max_size = 1024 * 5;

  InitTestDb();

  AutoRollLogger logger(Env::Default(), kTestDir, "", log_max_size, time);

  // Test the ability to roll by size
  RollLogFileBySizeTest(
      &logger, log_max_size,
      kSampleMessage + ":CompositeRollByTimeAndSizeLogger");

  // Test the ability to roll by Time
  RollLogFileByTimeTest( &logger, time,
      kSampleMessage + ":CompositeRollByTimeAndSizeLogger");
}

rocksdb::TEST	(	CacheTest	,
		EvictionPolicy
	)

Definition at line 177 of file cache_test.cc.

References ASSERT_EQ.

                                {
  Insert(100, 101);
  Insert(200, 201);

  // Frequently used entry must be kept around
  for (int i = 0; i < kCacheSize + 100; i++) {
    Insert(1000+i, 2000+i);
    ASSERT_EQ(2000+i, Lookup(1000+i));
    ASSERT_EQ(101, Lookup(100));
  }
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(-1, Lookup(200));
}

rocksdb::TEST	(	Coding	,
		Strings
	)

Definition at line 179 of file coding_test.cc.

References ASSERT_EQ, ASSERT_TRUE, GetLengthPrefixedSlice(), PutLengthPrefixedSlice(), and rocksdb::Slice::ToString().

                      {
  std::string s;
  PutLengthPrefixedSlice(&s, Slice(""));
  PutLengthPrefixedSlice(&s, Slice("foo"));
  PutLengthPrefixedSlice(&s, Slice("bar"));
  PutLengthPrefixedSlice(&s, Slice(std::string(200, 'x')));

  Slice input(s);
  Slice v;
  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
  ASSERT_EQ("", v.ToString());
  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
  ASSERT_EQ("foo", v.ToString());
  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
  ASSERT_EQ("bar", v.ToString());
  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
  ASSERT_EQ(std::string(200, 'x'), v.ToString());
  ASSERT_EQ("", input.ToString());
}

Here is the call graph for this function:

rocksdb::TEST	(	MemEnvTest	,
		DBTest
	)

Definition at line 186 of file memenv_test.cc.

References ASSERT_OK, ASSERT_TRUE, rocksdb::Options::create_if_missing, db, rocksdb::Options::env, env_, rocksdb::DB::Get(), rocksdb::Iterator::key(), rocksdb::DB::NewIterator(), rocksdb::Iterator::Next(), rocksdb::DB::Open(), rocksdb::DB::Put(), rocksdb::Iterator::SeekToFirst(), rocksdb::DBImpl::TEST_FlushMemTable(), rocksdb::Iterator::Valid(), and rocksdb::Iterator::value().

                         {
  Options options;
  options.create_if_missing = true;
  options.env = env_;
  DB* db;

  const Slice keys[] = {Slice("aaa"), Slice("bbb"), Slice("ccc")};
  const Slice vals[] = {Slice("foo"), Slice("bar"), Slice("baz")};

  ASSERT_OK(DB::Open(options, "/dir/db", &db));
  for (size_t i = 0; i < 3; ++i) {
    ASSERT_OK(db->Put(WriteOptions(), keys[i], vals[i]));
  }

  for (size_t i = 0; i < 3; ++i) {
    std::string res;
    ASSERT_OK(db->Get(ReadOptions(), keys[i], &res));
    ASSERT_TRUE(res == vals[i]);
  }

  Iterator* iterator = db->NewIterator(ReadOptions());
  iterator->SeekToFirst();
  for (size_t i = 0; i < 3; ++i) {
    ASSERT_TRUE(iterator->Valid());
    ASSERT_TRUE(keys[i] == iterator->key());
    ASSERT_TRUE(vals[i] == iterator->value());
    iterator->Next();
  }
  ASSERT_TRUE(!iterator->Valid());
  delete iterator;

  DBImpl* dbi = reinterpret_cast<DBImpl*>(db);
  ASSERT_OK(dbi->TEST_FlushMemTable());

  for (size_t i = 0; i < 3; ++i) {
    std::string res;
    ASSERT_OK(db->Get(ReadOptions(), keys[i], &res));
    ASSERT_TRUE(res == vals[i]);
  }

  delete db;
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		EvictionPolicyRef
	)

Definition at line 191 of file cache_test.cc.

References ASSERT_EQ, and EncodeKey().

                                   {
  Insert(100, 101);
  Insert(101, 102);
  Insert(102, 103);
  Insert(103, 104);
  Insert(200, 101);
  Insert(201, 102);
  Insert(202, 103);
  Insert(203, 104);
  Cache::Handle* h201 = cache_->Lookup(EncodeKey(200));
  Cache::Handle* h202 = cache_->Lookup(EncodeKey(201));
  Cache::Handle* h203 = cache_->Lookup(EncodeKey(202));
  Cache::Handle* h204 = cache_->Lookup(EncodeKey(203));
  Insert(300, 101);
  Insert(301, 102);
  Insert(302, 103);
  Insert(303, 104);

  // Insert entries much more than Cache capacity
  for (int i = 0; i < kCacheSize + 100; i++) {
    Insert(1000 + i, 2000 + i);
  }

  // Check whether the entries inserted in the beginning
  // are evicted. Ones without extra ref are evicted and
  // those with are not.
  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(-1, Lookup(101));
  ASSERT_EQ(-1, Lookup(102));
  ASSERT_EQ(-1, Lookup(103));

  ASSERT_EQ(-1, Lookup(300));
  ASSERT_EQ(-1, Lookup(301));
  ASSERT_EQ(-1, Lookup(302));
  ASSERT_EQ(-1, Lookup(303));

  ASSERT_EQ(101, Lookup(200));
  ASSERT_EQ(102, Lookup(201));
  ASSERT_EQ(103, Lookup(202));
  ASSERT_EQ(104, Lookup(203));

  // Cleaning up all the handles
  cache_->Release(h201);
  cache_->Release(h202);
  cache_->Release(h203);
  cache_->Release(h204);
}

Here is the call graph for this function:

rocksdb::TEST	(	WriteBatchTest	,
		Continue
	)

Definition at line 191 of file write_batch_test.cc.

References ASSERT_EQ, rocksdb::WriteBatch::Delete(), rocksdb::WriteBatch::Iterate(), rocksdb::WriteBatch::Merge(), rocksdb::WriteBatch::Put(), and rocksdb::WriteBatch::PutLogData().

                               {
  WriteBatch batch;

  struct Handler : public TestHandler {
    int num_seen = 0;
    virtual void Put(const Slice& key, const Slice& value) {
      ++num_seen;
      TestHandler::Put(key, value);
    }
    virtual void Merge(const Slice& key, const Slice& value) {
      ++num_seen;
      TestHandler::Merge(key, value);
    }
    virtual void LogData(const Slice& blob) {
      ++num_seen;
      TestHandler::LogData(blob);
    }
    virtual void Delete(const Slice& key) {
      ++num_seen;
      TestHandler::Delete(key);
    }
    virtual bool Continue() override {
      return num_seen < 3;
    }
  } handler;

  batch.Put(Slice("k1"), Slice("v1"));
  batch.PutLogData(Slice("blob1"));
  batch.Delete(Slice("k1"));
  batch.PutLogData(Slice("blob2"));
  batch.Merge(Slice("foo"), Slice("bar"));
  batch.Iterate(&handler);
  ASSERT_EQ(
            "Put(k1, v1)"
            "LogData(blob1)"
            "Delete(k1)",
            handler.seen);
}

Here is the call graph for this function:

rocksdb::TEST	(	AutoRollLoggerTest	,
		CreateLoggerFromOptions
	)

Definition at line 193 of file auto_roll_logger_test.cc.

References ASSERT_OK, ASSERT_TRUE, CreateLoggerFromOptions(), env, rocksdb::Options::log_file_time_to_roll, logger, and rocksdb::Options::max_log_file_size.

                                                  {
  Options options;
  shared_ptr<Logger> logger;

  // Normal logger
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, "", env, options, &logger));
  ASSERT_TRUE(dynamic_cast<PosixLogger*>(logger.get()));

  // Only roll by size
  InitTestDb();
  options.max_log_file_size = 1024;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, "", env, options, &logger));
  AutoRollLogger* auto_roll_logger =
    dynamic_cast<AutoRollLogger*>(logger.get());
  ASSERT_TRUE(auto_roll_logger);
  RollLogFileBySizeTest(
      auto_roll_logger, options.max_log_file_size,
      kSampleMessage + ":CreateLoggerFromOptions - size");

  // Only roll by Time
  InitTestDb();
  options.max_log_file_size = 0;
  options.log_file_time_to_roll = 1;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, "", env, options, &logger));
  auto_roll_logger =
    dynamic_cast<AutoRollLogger*>(logger.get());
  RollLogFileByTimeTest(
      auto_roll_logger, options.log_file_time_to_roll,
      kSampleMessage + ":CreateLoggerFromOptions - time");

  // roll by both Time and size
  InitTestDb();
  options.max_log_file_size = 1024 * 5;
  options.log_file_time_to_roll = 1;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, "", env, options, &logger));
  auto_roll_logger =
    dynamic_cast<AutoRollLogger*>(logger.get());
  RollLogFileBySizeTest(
      auto_roll_logger, options.max_log_file_size,
      kSampleMessage + ":CreateLoggerFromOptions - both");
  RollLogFileByTimeTest(
      auto_roll_logger, options.log_file_time_to_roll,
      kSampleMessage + ":CreateLoggerFromOptions - both");
}

Here is the call graph for this function:

rocksdb::TEST	(	DeleteFileTest	,
		PurgeObsoleteFilesTest
	)

Definition at line 194 of file deletefile_test.cc.

References rocksdb::DBImpl::CompactRange(), db_, dbname_, beast.util.Iter::first(), rocksdb::DBImpl::NewIterator(), options_, and rocksdb::Options::wal_dir.

                                             {
  CreateTwoLevels();
  // there should be only one (empty) log file because CreateTwoLevels()
  // flushes the memtables to disk
  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
  // 2 ssts, 1 manifest
  CheckFileTypeCounts(dbname_, 0, 2, 1);
  std::string first("0"), last("999999");
  Slice first_slice(first), last_slice(last);
  db_->CompactRange(&first_slice, &last_slice, true, 2);
  // 1 sst after compaction
  CheckFileTypeCounts(dbname_, 0, 1, 1);

  // this time, we keep an iterator alive
  ReopenDB(true);
  Iterator *itr = 0;
  CreateTwoLevels();
  itr = db_->NewIterator(ReadOptions());
  db_->CompactRange(&first_slice, &last_slice, true, 2);
  // 3 sst after compaction with live iterator
  CheckFileTypeCounts(dbname_, 0, 3, 1);
  delete itr;
  // 1 sst after iterator deletion
  CheckFileTypeCounts(dbname_, 0, 1, 1);

  CloseDB();
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		BitStream
	)

Definition at line 199 of file coding_test.cc.

References ASSERT_EQ, BitStreamGetInt(), and BitStreamPutInt().

                        {
  const int kNumBytes = 10;
  char bytes[kNumBytes+1];
  for (int i = 0; i < kNumBytes + 1; ++i) {
      bytes[i] = '\0';
  }

  // Simple byte aligned test.
  for (int i = 0; i < kNumBytes; ++i) {
    BitStreamPutInt(bytes, kNumBytes, i*8, 8, 255-i);

    ASSERT_EQ((unsigned char)bytes[i], (unsigned char)(255-i));
  }
  for (int i = 0; i < kNumBytes; ++i) {
    ASSERT_EQ(BitStreamGetInt(bytes, kNumBytes, i*8, 8), (uint32_t)(255-i));
  }
  ASSERT_EQ(bytes[kNumBytes], '\0');

  // Write and read back at strange offsets
  for (int i = 0; i < kNumBytes + 1; ++i) {
      bytes[i] = '\0';
  }
  for (int i = 0; i < kNumBytes; ++i) {
    BitStreamPutInt(bytes, kNumBytes, i*5+1, 4, (i * 7) % (1 << 4));
  }
  for (int i = 0; i < kNumBytes; ++i) {
    ASSERT_EQ(BitStreamGetInt(bytes, kNumBytes, i*5+1, 4),
              (uint32_t)((i * 7) % (1 << 4)));
  }
  ASSERT_EQ(bytes[kNumBytes], '\0');

  // Create 11011011 as a bit pattern
  for (int i = 0; i < kNumBytes + 1; ++i) {
      bytes[i] = '\0';
  }
  for (int i = 0; i < kNumBytes; ++i) {
    BitStreamPutInt(bytes, kNumBytes, i*8, 2, 3);
    BitStreamPutInt(bytes, kNumBytes, i*8+3, 2, 3);
    BitStreamPutInt(bytes, kNumBytes, i*8+6, 2, 3);

    ASSERT_EQ((unsigned char)bytes[i],
              (unsigned char)(3 + (3 << 3) + (3 << 6)));
  }
  ASSERT_EQ(bytes[kNumBytes], '\0');


  // Test large values
  for (int i = 0; i < kNumBytes + 1; ++i) {
      bytes[i] = '\0';
  }
  BitStreamPutInt(bytes, kNumBytes, 0, 64, (uint64_t)(-1));
  for (int i = 0; i < 64/8; ++i) {
    ASSERT_EQ((unsigned char)bytes[i],
              (unsigned char)(255));
  }
  ASSERT_EQ(bytes[64/8], '\0');


}

Here is the call graph for this function:

rocksdb::TEST	(	TablePropertiesTest	,
		InternalKeyPropertiesCollector
	)

Definition at line 200 of file table_properties_collector_test.cc.

References rocksdb::TableBuilder::Add(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, comparator, rocksdb::Options::comparator, rocksdb::FakeWritableFile::contents(), rocksdb::TableBuilder::Finish(), GetDeletedKeys(), GetVarint32(), rocksdb::Options::info_log, kTypeDeletion, kTypeValue, MakeBuilder(), OpenTable(), SanitizeOptions(), and rocksdb::Options::table_properties_collectors.

                                                          {
  InternalKey keys[] = {
    InternalKey("A", 0, ValueType::kTypeValue),
    InternalKey("B", 0, ValueType::kTypeValue),
    InternalKey("C", 0, ValueType::kTypeValue),
    InternalKey("W", 0, ValueType::kTypeDeletion),
    InternalKey("X", 0, ValueType::kTypeDeletion),
    InternalKey("Y", 0, ValueType::kTypeDeletion),
    InternalKey("Z", 0, ValueType::kTypeDeletion),
  };

  for (bool sanitized : { false, true }) {
    std::unique_ptr<TableBuilder> builder;
    std::unique_ptr<FakeWritableFile> writable;
    Options options;
    if (sanitized) {
      options.table_properties_collectors = {
        std::make_shared<RegularKeysStartWithA>()
      };
      // with sanitization, even regular properties collector will be able to
      // handle internal keys.
      auto comparator = options.comparator;
      // HACK: Set options.info_log to avoid writing log in
      // SanitizeOptions().
      options.info_log = std::make_shared<DumbLogger>();
      options = SanitizeOptions(
          "db",  // just a place holder
          nullptr,  // with skip internal key comparator
          nullptr,  // don't care filter policy
          options
      );
      options.comparator = comparator;
    } else {
      options.table_properties_collectors = {
        std::make_shared<InternalKeyPropertiesCollector>()
      };
    }

    MakeBuilder(options, &writable, &builder);
    for (const auto& k : keys) {
      builder->Add(k.Encode(), "val");
    }

    ASSERT_OK(builder->Finish());

    std::unique_ptr<TableReader> table_reader;
    OpenTable(options, writable->contents(), &table_reader);
    const auto& properties =
      table_reader->GetTableProperties().user_collected_properties;

    uint64_t deleted = GetDeletedKeys(properties);
    ASSERT_EQ(4u, deleted);

    if (sanitized) {
      uint32_t starts_with_A = 0;
      Slice key(properties.at("Count"));
      ASSERT_TRUE(GetVarint32(&key, &starts_with_A));
      ASSERT_EQ(1u, starts_with_A);
    }
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		Recovery
	)

Definition at line 201 of file corruption_test.cc.

References rocksdb::log::kBlockSize, and kLogFile.

                               {
  Build(100);
  Check(100, 100);
  Corrupt(kLogFile, 19, 1);      // WriteBatch tag for first record
  Corrupt(kLogFile, log::kBlockSize + 1000, 1);  // Somewhere in second block
  Reopen();

  // The 64 records in the first two log blocks are completely lost.
  Check(36, 36);
}

rocksdb::TEST	(	PerfContextTest	,
		KeyComparisonCount
	)

Definition at line 207 of file perf_context_test.cc.

References kDisable, kEnableCount, kEnableTime, ProfileKeyComparison(), and SetPerfLevel().

                                          {
  SetPerfLevel(kEnableCount);
  ProfileKeyComparison();

  SetPerfLevel(kDisable);
  ProfileKeyComparison();

  SetPerfLevel(kEnableTime);
  ProfileKeyComparison();
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		RecoverWriteError
	)

Definition at line 212 of file corruption_test.cc.

References ASSERT_TRUE, env_, and rocksdb::Status::ok().

                                        {
  env_.writable_file_error_ = true;
  Status s = TryReopen();
  ASSERT_TRUE(!s.ok());
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		NewFileErrorDuringWrite
	)

Definition at line 218 of file corruption_test.cc.

References ASSERT_GE, ASSERT_TRUE, db_, env_, kValueSize, rocksdb::Status::ok(), rocksdb::WriteBatch::Put(), rocksdb::crc32c::Value(), rocksdb::DBImpl::Write(), and rocksdb::Options::write_buffer_size.

                                              {
  // Do enough writing to force minor compaction
  env_.writable_file_error_ = true;
  const int num = 3 + (Options().write_buffer_size / kValueSize);
  std::string value_storage;
  Status s;
  bool failed = false;
  for (int i = 0; i < num; i++) {
    WriteBatch batch;
    batch.Put("a", Value(100, &value_storage));
    s = db_->Write(WriteOptions(), &batch);
    if (!s.ok()) {
      failed = true;
    }
    ASSERT_TRUE(!failed || !s.ok());
  }
  ASSERT_TRUE(!s.ok());
  ASSERT_GE(env_.num_writable_file_errors_, 1);
  env_.writable_file_error_ = false;
  Reopen();
}

Here is the call graph for this function:

rocksdb::TEST	(	PrefixTest	,
		PrefixHash
	)

Definition at line 221 of file prefix_test.cc.

References rocksdb::HistogramImpl::Add(), ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db, rocksdb::Env::Default(), rocksdb::DBImpl::Delete(), DestroyDB(), rocksdb::StopWatchNano::ElapsedNanos(), kDbName, rocksdb::DBImpl::NewIterator(), OpenDb(), perf_context, rocksdb::TestKey::prefix, std::chrono::prefix, rocksdb::ReadOptions::prefix, rocksdb::DBImpl::Put(), rocksdb::PerfContext::Reset(), SliceToTestKey(), TestKeyToSlice(), beast::IP::to_string(), rocksdb::HistogramImpl::ToString(), rocksdb::PerfContext::user_key_comparison_count, and value.

                             {

  DestroyDB(kDbName, Options());
  auto db = OpenDb();
  WriteOptions write_options;
  ReadOptions read_options;

  std::vector<uint64_t> prefixes;
  for (uint64_t i = 0; i < FLAGS_total_prefixes; ++i) {
    prefixes.push_back(i);
  }

  if (FLAGS_random_prefix) {
    std::random_shuffle(prefixes.begin(), prefixes.end());
  }

  // insert x random prefix, each with y continuous element.
  HistogramImpl hist_put_time;
  HistogramImpl hist_put_comparison;

  for (auto prefix : prefixes) {
     for (uint64_t sorted = 0; sorted < FLAGS_items_per_prefix; sorted++) {
      TestKey test_key(prefix, sorted);

      Slice key = TestKeyToSlice(test_key);
      std::string value = "v" + std::to_string(sorted);

      perf_context.Reset();
      StopWatchNano timer(Env::Default(), true);
      ASSERT_OK(db->Put(write_options, key, value));
      hist_put_time.Add(timer.ElapsedNanos());
      hist_put_comparison.Add(perf_context.user_key_comparison_count);
    }
  }

  std::cout << "Put key comparison: \n" << hist_put_comparison.ToString()
            << "Put time: \n" << hist_put_time.ToString();


  // test seek existing keys
  HistogramImpl hist_seek_time;
  HistogramImpl hist_seek_comparison;

  for (auto prefix : prefixes) {
    TestKey test_key(prefix, 0);
    Slice key = TestKeyToSlice(test_key);
    std::string value = "v" + std::to_string(0);

    Slice key_prefix;
    if (FLAGS_use_prefix_hash_memtable) {
      key_prefix = options.prefix_extractor->Transform(key);
      read_options.prefix = &key_prefix;
    }
    std::unique_ptr<Iterator> iter(db->NewIterator(read_options));

    perf_context.Reset();
    StopWatchNano timer(Env::Default(), true);
    uint64_t total_keys = 0;
    for (iter->Seek(key); iter->Valid(); iter->Next()) {
      if (FLAGS_trigger_deadlock) {
        std::cout << "Behold the deadlock!\n";
        db->Delete(write_options, iter->key());
      }
      auto test_key = SliceToTestKey(iter->key());
      if (test_key->prefix != prefix) break;
      total_keys++;
    }
    hist_seek_time.Add(timer.ElapsedNanos());
    hist_seek_comparison.Add(perf_context.user_key_comparison_count);
    ASSERT_EQ(total_keys, FLAGS_items_per_prefix);
  }

  std::cout << "Seek key comparison: \n"
            << hist_seek_comparison.ToString()
            << "Seek time: \n"
            << hist_seek_time.ToString();

  // test non-existing keys
  HistogramImpl hist_no_seek_time;
  HistogramImpl hist_no_seek_comparison;

  for (auto prefix = FLAGS_total_prefixes;
       prefix < FLAGS_total_prefixes + 100;
       prefix++) {
    TestKey test_key(prefix, 0);
    Slice key = TestKeyToSlice(test_key);

    if (FLAGS_use_prefix_hash_memtable) {
      Slice key_prefix = options.prefix_extractor->Transform(key);
      read_options.prefix = &key_prefix;
    }
    std::unique_ptr<Iterator> iter(db->NewIterator(read_options));

    perf_context.Reset();
    StopWatchNano timer(Env::Default(), true);
    iter->Seek(key);
    hist_no_seek_time.Add(timer.ElapsedNanos());
    hist_no_seek_comparison.Add(perf_context.user_key_comparison_count);
    ASSERT_TRUE(!iter->Valid());
  }

  std::cout << "non-existing Seek key comparison: \n"
            << hist_no_seek_comparison.ToString()
            << "non-existing Seek time: \n"
            << hist_no_seek_time.ToString();
}

Here is the call graph for this function:

rocksdb::TEST	(	DeleteFileTest	,
		DeleteFileWithIterator
	)

Definition at line 222 of file deletefile_test.cc.

References ASSERT_EQ, ASSERT_TRUE, db_, rocksdb::DBImpl::DeleteFile(), rocksdb::DBImpl::GetLiveFilesMetaData(), rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Status::ok(), rocksdb::Iterator::SeekToFirst(), rocksdb::Status::ToString(), and rocksdb::Iterator::Valid().

                                             {
  CreateTwoLevels();
  ReadOptions options;
  Iterator* it = db_->NewIterator(options);
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);

  std::string level2file = "";

  ASSERT_EQ((int)metadata.size(), 2);
  if (metadata[0].level == 1) {
    level2file = metadata[1].name;
  } else {
    level2file = metadata[0].name;
  }

  Status status = db_->DeleteFile(level2file);
  fprintf(stdout, "Deletion status %s: %s\n",
          level2file.c_str(), status.ToString().c_str());
  ASSERT_TRUE(status.ok());
  it->SeekToFirst();
  int numKeysIterated = 0;
  while(it->Valid()) {
    numKeysIterated++;
    it->Next();
  }
  ASSERT_EQ(numKeysIterated, 50000);
  delete it;
  CloseDB();
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		SimpleTest
	)

Definition at line 222 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, ASSERT_TRUE, db, rocksdb::StringLists::Get(), and OpenDb().

                                           {
  auto db = OpenDb(',');
  StringLists slists(db);

  slists.Append("k1", "v1");
  slists.Append("k1", "v2");
  slists.Append("k1", "v3");

  std::string res;
  bool status = slists.Get("k1", &res);

  ASSERT_TRUE(status);
  ASSERT_EQ(res, "v1,v2,v3");
}

Here is the call graph for this function:

rocksdb::TEST	(	PerfContextTest	,
		SeekKeyComparison
	)

Definition at line 230 of file perf_context_test.cc.

References rocksdb::HistogramImpl::Add(), ASSERT_EQ, ASSERT_TRUE, db, rocksdb::Env::Default(), DestroyDB(), rocksdb::StopWatchNano::ElapsedNanos(), FLAGS_random_key, FLAGS_total_keys, kDbName, kEnableTime, rocksdb::DBImpl::NewIterator(), OpenDb(), perf_context, rocksdb::DBImpl::Put(), rocksdb::PerfContext::Reset(), SetPerfLevel(), rocksdb::StopWatchNano::Start(), beast::IP::to_string(), rocksdb::HistogramImpl::ToString(), rocksdb::PerfContext::user_key_comparison_count, value, and rocksdb::PerfContext::wal_write_time.

                                         {
  DestroyDB(kDbName, Options());
  auto db = OpenDb();
  WriteOptions write_options;
  ReadOptions read_options;

  std::cout << "Inserting " << FLAGS_total_keys << " key/value pairs\n...\n";

  std::vector<int> keys;
  for (int i = 0; i < FLAGS_total_keys; ++i) {
    keys.push_back(i);
  }

  if (FLAGS_random_key) {
    std::random_shuffle(keys.begin(), keys.end());
  }

  HistogramImpl hist_put_time;
  HistogramImpl hist_wal_time;
  HistogramImpl hist_time_diff;

  SetPerfLevel(kEnableTime);
  StopWatchNano timer(Env::Default());
  for (const int i : keys) {
    std::string key = "k" + std::to_string(i);
    std::string value = "v" + std::to_string(i);

    perf_context.Reset();
    timer.Start();
    db->Put(write_options, key, value);
    auto put_time = timer.ElapsedNanos();
    hist_put_time.Add(put_time);
    hist_wal_time.Add(perf_context.wal_write_time);
    hist_time_diff.Add(put_time - perf_context.wal_write_time);
  }

  std::cout << "Put time:\n" << hist_put_time.ToString()
            << "WAL time:\n" << hist_wal_time.ToString()
            << "time diff:\n" << hist_time_diff.ToString();

  HistogramImpl hist_seek;
  HistogramImpl hist_next;

  for (int i = 0; i < FLAGS_total_keys; ++i) {
    std::string key = "k" + std::to_string(i);
    std::string value = "v" + std::to_string(i);

    std::unique_ptr<Iterator> iter(db->NewIterator(read_options));
    perf_context.Reset();
    iter->Seek(key);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->value().ToString(), value);
    hist_seek.Add(perf_context.user_key_comparison_count);
  }

  std::unique_ptr<Iterator> iter(db->NewIterator(read_options));
  for (iter->SeekToFirst(); iter->Valid();) {
    perf_context.Reset();
    iter->Next();
    hist_next.Add(perf_context.user_key_comparison_count);
  }

  std::cout << "Seek:\n" << hist_seek.ToString()
            << "Next:\n" << hist_next.ToString();
}

Here is the call graph for this function:

rocksdb::TEST	(	WriteBatchTest	,
		PutGatherSlices
	)

Definition at line 230 of file write_batch_test.cc.

References ASSERT_EQ, rocksdb::WriteBatch::Count(), PrintContents(), rocksdb::WriteBatch::Put(), and rocksdb::WriteBatchInternal::SetSequence().

                                      {
  WriteBatch batch;
  batch.Put(Slice("foo"), Slice("bar"));

  {
    // Try a write where the key is one slice but the value is two
    Slice key_slice("baz");
    Slice value_slices[2] = { Slice("header"), Slice("payload") };
    batch.Put(SliceParts(&key_slice, 1),
              SliceParts(value_slices, 2));
  }

  {
    // One where the key is composite but the value is a single slice
    Slice key_slices[3] = { Slice("key"), Slice("part2"), Slice("part3") };
    Slice value_slice("value");
    batch.Put(SliceParts(key_slices, 3),
              SliceParts(&value_slice, 1));
  }

  WriteBatchInternal::SetSequence(&batch, 100);
  ASSERT_EQ("Put(baz, headerpayload)@101"
            "Put(foo, bar)@100"
            "Put(keypart2part3, value)@102",
            PrintContents(&batch));
  ASSERT_EQ(3, batch.Count());
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		SimpleDelimiterTest
	)

Definition at line 237 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, db, rocksdb::StringLists::Get(), and OpenDb().

                                                    {
  auto db = OpenDb('|');
  StringLists slists(db);

  slists.Append("k1", "v1");
  slists.Append("k1", "v2");
  slists.Append("k1", "v3");

  std::string res;
  slists.Get("k1", &res);
  ASSERT_EQ(res, "v1|v2|v3");
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		EvictionPolicyRef2
	)

Definition at line 239 of file cache_test.cc.

References ASSERT_EQ, and EncodeKey().

                                    {
  std::vector<Cache::Handle*> handles;

  Insert(100, 101);
  // Insert entries much more than Cache capacity
  for (int i = 0; i < kCacheSize + 100; i++) {
    Insert(1000 + i, 2000 + i);
    if (i < kCacheSize ) {
      handles.push_back(cache_->Lookup(EncodeKey(1000 + i)));
    }
  }

  // Make sure referenced keys are also possible to be deleted
  // if there are not sufficient non-referenced keys
  for (int i = 0; i < 5; i++) {
    ASSERT_EQ(-1, Lookup(1000 + i));
  }

  for (int i = kCacheSize; i < kCacheSize + 100; i++) {
    ASSERT_EQ(2000 + i, Lookup(1000 + i));
  }
  ASSERT_EQ(-1, Lookup(100));

  // Cleaning up all the handles
  while (handles.size() > 0) {
    cache_->Release(handles.back());
    handles.pop_back();
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		TableFile
	)

Definition at line 240 of file corruption_test.cc.

References db_, kTableFile, rocksdb::DBImpl::TEST_CompactRange(), and rocksdb::DBImpl::TEST_FlushMemTable().

                                {
  Build(100);
  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
  dbi->TEST_FlushMemTable();
  dbi->TEST_CompactRange(0, nullptr, nullptr);
  dbi->TEST_CompactRange(1, nullptr, nullptr);

  Corrupt(kTableFile, 100, 1);
  Check(99, 99);
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		OneValueNoDelimiterTest
	)

Definition at line 250 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, db, rocksdb::StringLists::Get(), and OpenDb().

                                                        {
  auto db = OpenDb('!');
  StringLists slists(db);

  slists.Append("random_key", "single_val");

  std::string res;
  slists.Get("random_key", &res);
  ASSERT_EQ(res, "single_val");
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		TableFileIndexData
	)

Definition at line 251 of file corruption_test.cc.

References db_, kTableFile, and rocksdb::DBImpl::TEST_FlushMemTable().

                                         {
  Build(10000);  // Enough to build multiple Tables
  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
  dbi->TEST_FlushMemTable();

  Corrupt(kTableFile, -2000, 500);
  Reopen();
  Check(5000, 9999);
}

Here is the call graph for this function:

rocksdb::TEST	(	DeleteFileTest	,
		DeleteLogFiles
	)

Definition at line 253 of file deletefile_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, ASSERT_TRUE, db_, rocksdb::DBImpl::DeleteFile(), env_, rocksdb::Env::FileExists(), rocksdb::DBImpl::Flush(), rocksdb::DBImpl::GetSortedWalFiles(), kAliveLogFile, kArchivedLogFile, ripple::Resource::ok, options_, and rocksdb::Options::wal_dir.

                                     {
  AddKeys(10, 0);
  VectorLogPtr logfiles;
  db_->GetSortedWalFiles(logfiles);
  ASSERT_GT(logfiles.size(), 0UL);
  // Take the last log file which is expected to be alive and try to delete it
  // Should not succeed because live logs are not allowed to be deleted
  std::unique_ptr<LogFile> alive_log = std::move(logfiles.back());
  ASSERT_EQ(alive_log->Type(), kAliveLogFile);
  ASSERT_TRUE(env_->FileExists(options_.wal_dir + "/" + alive_log->PathName()));
  fprintf(stdout, "Deleting alive log file %s\n",
          alive_log->PathName().c_str());
  ASSERT_TRUE(!db_->DeleteFile(alive_log->PathName()).ok());
  ASSERT_TRUE(env_->FileExists(options_.wal_dir + "/" + alive_log->PathName()));
  logfiles.clear();

  // Call Flush to bring about a new working log file and add more keys
  // Call Flush again to flush out memtable and move alive log to archived log
  // and try to delete the archived log file
  FlushOptions fopts;
  db_->Flush(fopts);
  AddKeys(10, 0);
  db_->Flush(fopts);
  db_->GetSortedWalFiles(logfiles);
  ASSERT_GT(logfiles.size(), 0UL);
  std::unique_ptr<LogFile> archived_log = std::move(logfiles.front());
  ASSERT_EQ(archived_log->Type(), kArchivedLogFile);
  ASSERT_TRUE(env_->FileExists(options_.wal_dir + "/" +
        archived_log->PathName()));
  fprintf(stdout, "Deleting archived log file %s\n",
          archived_log->PathName().c_str());
  ASSERT_OK(db_->DeleteFile(archived_log->PathName()));
  ASSERT_TRUE(!env_->FileExists(options_.wal_dir + "/" +
        archived_log->PathName()));
  CloseDB();
}

Here is the call graph for this function:

rocksdb::TEST	(	RedisListsTest	,
		InsertTest
	)

Definition at line 253 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::InsertAfter(), rocksdb::RedisLists::InsertBefore(), rocksdb::RedisLists::Length(), and rocksdb::RedisLists::PushLeft().

                                 {
  RedisLists redis(kDefaultDbName, options, true);

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Insert on empty list (return 0, and do not crash)
  ASSERT_EQ(redis.InsertBefore("k1", "non-exist", "a"), 0);
  ASSERT_EQ(redis.InsertAfter("k1", "other-non-exist", "c"), 0);
  ASSERT_EQ(redis.Length("k1"), 0);

  // Push some preliminary stuff [g, f, e, d, c, b, a]
  redis.PushLeft("k1", "a");
  redis.PushLeft("k1", "b");
  redis.PushLeft("k1", "c");
  redis.PushLeft("k1", "d");
  redis.PushLeft("k1", "e");
  redis.PushLeft("k1", "f");
  redis.PushLeft("k1", "g");
  ASSERT_EQ(redis.Length("k1"), 7);

  // Test InsertBefore
  int newLength = redis.InsertBefore("k1", "e", "hello");
  ASSERT_EQ(newLength, 8);
  ASSERT_EQ(redis.Length("k1"), newLength);
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "f");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "e");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "hello");

  // Test InsertAfter
  newLength =  redis.InsertAfter("k1", "c", "bye");
  ASSERT_EQ(newLength, 9);
  ASSERT_EQ(redis.Length("k1"), newLength);
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "bye");

  // Test bad value on InsertBefore
  newLength = redis.InsertBefore("k1", "yo", "x");
  ASSERT_EQ(newLength, 9);
  ASSERT_EQ(redis.Length("k1"), newLength);

  // Test bad value on InsertAfter
  newLength = redis.InsertAfter("k1", "xxxx", "y");
  ASSERT_EQ(newLength, 9);
  ASSERT_EQ(redis.Length("k1"), newLength);

  // Test InsertBefore beginning
  newLength = redis.InsertBefore("k1", "g", "begggggggggggggggg");
  ASSERT_EQ(newLength, 10);
  ASSERT_EQ(redis.Length("k1"), newLength);

  // Test InsertAfter end
  newLength = redis.InsertAfter("k1", "a", "enddd");
  ASSERT_EQ(newLength, 11);
  ASSERT_EQ(redis.Length("k1"), newLength);

  // Make sure nothing weird happened.
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "begggggggggggggggg");
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "g");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "f");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "hello");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "e");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "d");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "c");
  ASSERT_TRUE(redis.Index("k1", 7, &tempv));
  ASSERT_EQ(tempv, "bye");
  ASSERT_TRUE(redis.Index("k1", 8, &tempv));
  ASSERT_EQ(tempv, "b");
  ASSERT_TRUE(redis.Index("k1", 9, &tempv));
  ASSERT_EQ(tempv, "a");
  ASSERT_TRUE(redis.Index("k1", 10, &tempv));
  ASSERT_EQ(tempv, "enddd");
}

Here is the call graph for this function:

rocksdb::TEST	(	Coding	,
		BitStreamConvenienceFuncs
	)

Definition at line 259 of file coding_test.cc.

References ASSERT_EQ, BitStreamGetInt(), and BitStreamPutInt().

                                        {
  std::string bytes(1, '\0');

  // Check that independent changes to byte are preserved.
  BitStreamPutInt(&bytes, 0, 2, 3);
  BitStreamPutInt(&bytes, 3, 2, 3);
  BitStreamPutInt(&bytes, 6, 2, 3);
  ASSERT_EQ((unsigned char)bytes[0], (unsigned char)(3 + (3 << 3) + (3 << 6)));
  ASSERT_EQ(BitStreamGetInt(&bytes, 0, 2), 3u);
  ASSERT_EQ(BitStreamGetInt(&bytes, 3, 2), 3u);
  ASSERT_EQ(BitStreamGetInt(&bytes, 6, 2), 3u);
  Slice slice(bytes);
  ASSERT_EQ(BitStreamGetInt(&slice, 0, 2), 3u);
  ASSERT_EQ(BitStreamGetInt(&slice, 3, 2), 3u);
  ASSERT_EQ(BitStreamGetInt(&slice, 6, 2), 3u);

  // Test overlapping crossing over byte boundaries
  bytes = std::string(2, '\0');
  BitStreamPutInt(&bytes, 6, 4, 15);
  ASSERT_EQ((unsigned char)bytes[0], 3 << 6);
  ASSERT_EQ((unsigned char)bytes[1], 3);
  ASSERT_EQ(BitStreamGetInt(&bytes, 6, 4), 15u);
  slice = Slice(bytes);
  ASSERT_EQ(BitStreamGetInt(&slice, 6, 4), 15u);

  // Test 64-bit number
  bytes = std::string(64/8, '\0');
  BitStreamPutInt(&bytes, 0, 64, (uint64_t)(-1));
  ASSERT_EQ(BitStreamGetInt(&bytes, 0, 64), (uint64_t)(-1));
  slice = Slice(bytes);
  ASSERT_EQ(BitStreamGetInt(&slice, 0, 64), (uint64_t)(-1));
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		MissingDescriptor
	)

Definition at line 261 of file corruption_test.cc.

References RepairDB().

                                        {
  Build(1000);
  RepairDB();
  Reopen();
  Check(1000, 1000);
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		VariousKeys
	)

Definition at line 261 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, ASSERT_TRUE, db, rocksdb::StringLists::Get(), and OpenDb().

                                            {
  auto db = OpenDb('\n');
  StringLists slists(db);

  slists.Append("c", "asdasd");
  slists.Append("a", "x");
  slists.Append("b", "y");
  slists.Append("a", "t");
  slists.Append("a", "r");
  slists.Append("b", "2");
  slists.Append("c", "asdasd");

  std::string a, b, c;
  bool sa, sb, sc;
  sa = slists.Get("a", &a);
  sb = slists.Get("b", &b);
  sc = slists.Get("c", &c);

  ASSERT_TRUE(sa && sb && sc); // All three keys should have been found

  ASSERT_EQ(a, "x\nt\nr");
  ASSERT_EQ(b, "y\n2");
  ASSERT_EQ(c, "asdasd\nasdasd");
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		SequenceNumberRecovery
	)

Definition at line 268 of file corruption_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::Get(), rocksdb::DBImpl::Put(), and RepairDB().

                                             {
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "v1"));
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "v2"));
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "v3"));
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "v4"));
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "v5"));
  RepairDB();
  Reopen();
  std::string v;
  ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
  ASSERT_EQ("v5", v);
  // Write something.  If sequence number was not recovered properly,
  // it will be hidden by an earlier write.
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "v6"));
  ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
  ASSERT_EQ("v6", v);
  Reopen();
  ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
  ASSERT_EQ("v6", v);
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		EvictionPolicyRefLargeScanLimit
	)

Definition at line 269 of file cache_test.cc.

References ASSERT_EQ, and EncodeKey().

                                                 {
  std::vector<Cache::Handle*> handles2;

  // Cache2 has a cache RemoveScanCountLimit higher than cache size
  // so it would trigger a boundary condition.

  // Populate the cache with 10 more keys than its size.
  // Reference all keys except one close to the end.
  for (int i = 0; i < kCacheSize2 + 10; i++) {
    Insert2(1000 + i, 2000+i);
    if (i != kCacheSize2 ) {
      handles2.push_back(cache2_->Lookup(EncodeKey(1000 + i)));
    }
  }

  // Make sure referenced keys are also possible to be deleted
  // if there are not sufficient non-referenced keys
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(-1, Lookup2(1000 + i));
  }
  // The non-referenced value is deleted even if it's accessed
  // recently.
  ASSERT_EQ(-1, Lookup2(1000 + kCacheSize2));
  // Other values recently accessed are not deleted since they
  // are referenced.
  for (int i = kCacheSize2 - 10; i < kCacheSize2 + 10; i++) {
    if (i != kCacheSize2) {
      ASSERT_EQ(2000 + i, Lookup2(1000 + i));
    }
  }

  // Cleaning up all the handles
  while (handles2.size() > 0) {
    cache2_->Release(handles2.back());
    handles2.pop_back();
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		RandomMixGetAppend
	)

Definition at line 287 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, db, rocksdb::StringLists::Get(), OpenDb(), and rocksdb::Random::Uniform().

                                                   {
  auto db = OpenDb(' ');
  StringLists slists(db);

  // Generate a list of random keys and values
  const int kWordCount = 15;
  std::string words[] = {"sdasd", "triejf", "fnjsdfn", "dfjisdfsf", "342839",
                         "dsuha", "mabuais", "sadajsid", "jf9834hf", "2d9j89",
                         "dj9823jd", "a", "dk02ed2dh", "$(jd4h984$(*", "mabz"};
  const int kKeyCount = 6;
  std::string keys[] = {"dhaiusdhu", "denidw", "daisda", "keykey", "muki",
                        "shzassdianmd"};

  // Will store a local copy of all data in order to verify correctness
  std::map<std::string, std::string> parallel_copy;

  // Generate a bunch of random queries (Append and Get)!
  enum query_t  { APPEND_OP, GET_OP, NUM_OPS };
  Random randomGen(1337);       //deterministic seed; always get same results!

  const int kNumQueries = 30;
  for (int q=0; q<kNumQueries; ++q) {
    // Generate a random query (Append or Get) and random parameters
    query_t query = (query_t)randomGen.Uniform((int)NUM_OPS);
    std::string key = keys[randomGen.Uniform((int)kKeyCount)];
    std::string word = words[randomGen.Uniform((int)kWordCount)];

    // Apply the query and any checks.
    if (query == APPEND_OP) {

      // Apply the rocksdb test-harness Append defined above
      slists.Append(key, word);  //apply the rocksdb append

      // Apply the similar "Append" to the parallel copy
      if (parallel_copy[key].size() > 0) {
        parallel_copy[key] += " " + word;
      } else {
        parallel_copy[key] = word;
      }

    } else if (query == GET_OP) {
      // Assumes that a non-existent key just returns <empty>
      std::string res;
      slists.Get(key, &res);
      ASSERT_EQ(res, parallel_copy[key]);
    }

  }

}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		CorruptedDescriptor
	)

Definition at line 289 of file corruption_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db_, rocksdb::DBImpl::Get(), kDescriptorFile, rocksdb::Status::ok(), rocksdb::DBImpl::Put(), RepairDB(), and rocksdb::DBImpl::TEST_FlushMemTable().

                                          {
  ASSERT_OK(db_->Put(WriteOptions(), "foo", "hello"));
  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
  dbi->TEST_FlushMemTable();
  dbi->TEST_CompactRange(0, nullptr, nullptr);

  Corrupt(kDescriptorFile, 0, 1000);
  Status s = TryReopen();
  ASSERT_TRUE(!s.ok());

  RepairDB();
  Reopen();
  std::string v;
  ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
  ASSERT_EQ("hello", v);
}

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		ConcurrentWithoutThreads
	)

Definition at line 293 of file skiplist_test.cc.

References rocksdb::test::RandomSeed(), rocksdb::ConcurrentTest::ReadStep(), test, and rocksdb::ConcurrentTest::WriteStep().

                                         {
  ConcurrentTest test;
  Random rnd(test::RandomSeed());
  for (int i = 0; i < 10000; i++) {
    test.ReadStep(&rnd);
    test.WriteStep(&rnd);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		CompactionInputError
	)

Definition at line 306 of file corruption_test.cc.

References ASSERT_EQ, db_, kTableFile, rocksdb::DBImpl::MaxMemCompactionLevel(), NumberToString(), and rocksdb::DBImpl::TEST_FlushMemTable().

                                           {
  Build(10);
  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
  dbi->TEST_FlushMemTable();
  const int last = dbi->MaxMemCompactionLevel();
  ASSERT_EQ(1, Property("rocksdb.num-files-at-level" + NumberToString(last)));

  Corrupt(kTableFile, 100, 1);
  Check(9, 9);

  // Force compactions by writing lots of values
  Build(10000);
  Check(10000, 10000);
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		HeavyEntries
	)

Definition at line 309 of file cache_test.cc.

References ASSERT_EQ, and ASSERT_LE.

                              {
  // Add a bunch of light and heavy entries and then count the combined
  // size of items still in the cache, which must be approximately the
  // same as the total capacity.
  const int kLight = 1;
  const int kHeavy = 10;
  int added = 0;
  int index = 0;
  while (added < 2*kCacheSize) {
    const int weight = (index & 1) ? kLight : kHeavy;
    Insert(index, 1000+index, weight);
    added += weight;
    index++;
  }

  int cached_weight = 0;
  for (int i = 0; i < index; i++) {
    const int weight = (i & 1 ? kLight : kHeavy);
    int r = Lookup(i);
    if (r >= 0) {
      cached_weight += weight;
      ASSERT_EQ(1000+i, r);
    }
  }
  ASSERT_LE(cached_weight, kCacheSize + kCacheSize/10);
}

rocksdb::TEST	(	TtlTest	,
		NoEffect
	)

Definition at line 320 of file ttl_test.cc.

                        {
  MakeKVMap(kSampleSize_);
  int boundary1 = kSampleSize_ / 3;
  int boundary2 = 2 * boundary1;

  OpenTtl();
  PutValues(0, boundary1);                       //T=0: Set1 never deleted
  SleepCompactCheck(1, 0, boundary1);            //T=1: Set1 still there
  CloseTtl();

  OpenTtl(0);
  PutValues(boundary1, boundary2 - boundary1);   //T=1: Set2 never deleted
  SleepCompactCheck(1, 0, boundary2);            //T=2: Sets1 & 2 still there
  CloseTtl();

  OpenTtl(-1);
  PutValues(boundary2, kSampleSize_ - boundary2); //T=3: Set3 never deleted
  SleepCompactCheck(1, 0, kSampleSize_, true);    //T=4: Sets 1,2,3 still there
  CloseTtl();
}

rocksdb::TEST	(	CorruptionTest	,
		CompactionInputErrorParanoid
	)

Definition at line 321 of file corruption_test.cc.

References ASSERT_EQ, ASSERT_TRUE, db_, kTableFile, rocksdb::DBImpl::NumberLevels(), rocksdb::Status::ok(), rocksdb::Options::paranoid_checks, rocksdb::DBImpl::Put(), rocksdb::DBImpl::TEST_FlushMemTable(), rocksdb::DBImpl::TEST_WaitForCompact(), rocksdb::crc32c::Value(), and rocksdb::Options::write_buffer_size.

                                                   {
  Options options;
  options.paranoid_checks = true;
  options.write_buffer_size = 1048576;
  Reopen(&options);
  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);

  // Fill levels >= 1 so memtable compaction outputs to level 1
  for (int level = 1; level < dbi->NumberLevels(); level++) {
    dbi->Put(WriteOptions(), "", "begin");
    dbi->Put(WriteOptions(), "~", "end");
    dbi->TEST_FlushMemTable();
  }

  Build(10);
  dbi->TEST_FlushMemTable();
  dbi->TEST_WaitForCompact();
  ASSERT_EQ(1, Property("rocksdb.num-files-at-level0"));

  Corrupt(kTableFile, 100, 1);
  Check(9, 9);

  // Write must eventually fail because of corrupted table
  Status s;
  std::string tmp1, tmp2;
  bool failed = false;
  for (int i = 0; i < 10000 && s.ok(); i++) {
    s = db_->Put(WriteOptions(), Key(i, &tmp1), Value(i, &tmp2));
    if (!s.ok()) {
      failed = true;
    }
    // if one write failed, every subsequent write must fail, too
    ASSERT_TRUE(!failed || !s.ok()) << "write did not fail in a corrupted db";
  }
  ASSERT_TRUE(!s.ok()) << "write did not fail in corrupted paranoid db";
}

Here is the call graph for this function:

rocksdb::TEST	(	CacheTest	,
		NewId
	)

Definition at line 336 of file cache_test.cc.

References ASSERT_NE.

                       {
  uint64_t a = cache_->NewId();
  uint64_t b = cache_->NewId();
  ASSERT_NE(a, b);
}

rocksdb::TEST	(	RedisListsTest	,
		SetTest
	)

Definition at line 337 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PushLeft(), and rocksdb::RedisLists::Set().

                              {
  RedisLists redis(kDefaultDbName, options, true);

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Set on empty list (return false, and do not crash)
  ASSERT_EQ(redis.Set("k1", 7, "a"), false);
  ASSERT_EQ(redis.Set("k1", 0, "a"), false);
  ASSERT_EQ(redis.Set("k1", -49, "cx"), false);
  ASSERT_EQ(redis.Length("k1"), 0);

  // Push some preliminary stuff [g, f, e, d, c, b, a]
  redis.PushLeft("k1", "a");
  redis.PushLeft("k1", "b");
  redis.PushLeft("k1", "c");
  redis.PushLeft("k1", "d");
  redis.PushLeft("k1", "e");
  redis.PushLeft("k1", "f");
  redis.PushLeft("k1", "g");
  ASSERT_EQ(redis.Length("k1"), 7);

  // Test Regular Set
  ASSERT_TRUE(redis.Set("k1", 0, "0"));
  ASSERT_TRUE(redis.Set("k1", 3, "3"));
  ASSERT_TRUE(redis.Set("k1", 6, "6"));
  ASSERT_TRUE(redis.Set("k1", 2, "2"));
  ASSERT_TRUE(redis.Set("k1", 5, "5"));
  ASSERT_TRUE(redis.Set("k1", 1, "1"));
  ASSERT_TRUE(redis.Set("k1", 4, "4"));

  ASSERT_EQ(redis.Length("k1"), 7); // Size should not change
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "0");
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "1");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "2");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "3");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "4");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "5");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "6");

  // Set with negative indices
  ASSERT_TRUE(redis.Set("k1", -7, "a"));
  ASSERT_TRUE(redis.Set("k1", -4, "d"));
  ASSERT_TRUE(redis.Set("k1", -1, "g"));
  ASSERT_TRUE(redis.Set("k1", -5, "c"));
  ASSERT_TRUE(redis.Set("k1", -2, "f"));
  ASSERT_TRUE(redis.Set("k1", -6, "b"));
  ASSERT_TRUE(redis.Set("k1", -3, "e"));

  ASSERT_EQ(redis.Length("k1"), 7); // Size should not change
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "a");
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "b");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "c");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "d");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "e");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "f");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "g");

  // Bad indices (just out-of-bounds / off-by-one check)
  ASSERT_EQ(redis.Set("k1", -8, "off-by-one in negative index"), false);
  ASSERT_EQ(redis.Set("k1", 7, "off-by-one-error in positive index"), false);
  ASSERT_EQ(redis.Set("k1", 43892, "big random index should fail"), false);
  ASSERT_EQ(redis.Set("k1", -21391, "large negative index should fail"), false);

  // One last check (to make sure nothing weird happened)
  ASSERT_EQ(redis.Length("k1"), 7); // Size should not change
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "a");
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "b");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "c");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "d");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "e");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "f");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "g");
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		BIGRandomMixGetAppend
	)

Definition at line 338 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, db, rocksdb::StringLists::Get(), OpenDb(), and rocksdb::Random::Uniform().

                                                      {
  auto db = OpenDb(' ');
  StringLists slists(db);

  // Generate a list of random keys and values
  const int kWordCount = 15;
  std::string words[] = {"sdasd", "triejf", "fnjsdfn", "dfjisdfsf", "342839",
                         "dsuha", "mabuais", "sadajsid", "jf9834hf", "2d9j89",
                         "dj9823jd", "a", "dk02ed2dh", "$(jd4h984$(*", "mabz"};
  const int kKeyCount = 6;
  std::string keys[] = {"dhaiusdhu", "denidw", "daisda", "keykey", "muki",
                        "shzassdianmd"};

  // Will store a local copy of all data in order to verify correctness
  std::map<std::string, std::string> parallel_copy;

  // Generate a bunch of random queries (Append and Get)!
  enum query_t  { APPEND_OP, GET_OP, NUM_OPS };
  Random randomGen(9138204);       // deterministic seed

  const int kNumQueries = 1000;
  for (int q=0; q<kNumQueries; ++q) {
    // Generate a random query (Append or Get) and random parameters
    query_t query = (query_t)randomGen.Uniform((int)NUM_OPS);
    std::string key = keys[randomGen.Uniform((int)kKeyCount)];
    std::string word = words[randomGen.Uniform((int)kWordCount)];

    //Apply the query and any checks.
    if (query == APPEND_OP) {

      // Apply the rocksdb test-harness Append defined above
      slists.Append(key, word);  //apply the rocksdb append

      // Apply the similar "Append" to the parallel copy
      if (parallel_copy[key].size() > 0) {
        parallel_copy[key] += " " + word;
      } else {
        parallel_copy[key] = word;
      }

    } else if (query == GET_OP) {
      // Assumes that a non-existent key just returns <empty>
      std::string res;
      slists.Get(key, &res);
      ASSERT_EQ(res, parallel_copy[key]);
    }

  }

}

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		PresentDuringTTL
	)

Definition at line 342 of file ttl_test.cc.

                                {
  MakeKVMap(kSampleSize_);

  OpenTtl(2);                                 // T=0:Open the db with ttl = 2
  PutValues(0, kSampleSize_);                  // T=0:Insert Set1. Delete at t=2
  SleepCompactCheck(1, 0, kSampleSize_, true); // T=1:Set1 should still be there
  CloseTtl();
}

rocksdb::TEST	(	TtlTest	,
		AbsentAfterTTL
	)

Definition at line 352 of file ttl_test.cc.

                              {
  MakeKVMap(kSampleSize_);

  OpenTtl(1);                                  // T=0:Open the db with ttl = 2
  PutValues(0, kSampleSize_);                  // T=0:Insert Set1. Delete at t=2
  SleepCompactCheck(2, 0, kSampleSize_, false); // T=2:Set1 should not be there
  CloseTtl();
}

rocksdb::TEST	(	CacheTest	,
		BadEviction
	)

Definition at line 357 of file cache_test.cc.

References ASSERT_TRUE, deleter(), NewLRUCache(), beast::IP::to_string(), and rocksdb::crc32c::Value().

                             {
  int n = 10;

  // a LRUCache with n entries and one shard only
  std::shared_ptr<Cache> cache = NewLRUCache(n, 0);

  std::vector<Cache::Handle*> handles(n+1);

  // Insert n+1 entries, but not releasing.
  for (int i = 0; i < n+1; i++) {
    std::string key = std::to_string(i+1);
    handles[i] = cache->Insert(key, new Value(i+1), 1, &deleter);
  }

  // Guess what's in the cache now?
  for (int i = 0; i < n+1; i++) {
    std::string key = std::to_string(i+1);
    auto h = cache->Lookup(key);
    std::cout << key << (h?" found\n":" not found\n");
    // Only the first entry should be missing
    ASSERT_TRUE(h || i == 0);
    if (h) cache->Release(h);
  }

  for (int i = 0; i < n+1; i++) {
    cache->Release(handles[i]);
  }
  std::cout << "Poor entries\n";
}

Here is the call graph for this function:

rocksdb::TEST	(	CorruptionTest	,
		UnrelatedKeys
	)

Definition at line 358 of file corruption_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::Get(), kTableFile, rocksdb::DBImpl::Put(), rocksdb::DBImpl::TEST_FlushMemTable(), and rocksdb::crc32c::Value().

                                    {
  Build(10);
  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
  dbi->TEST_FlushMemTable();
  Corrupt(kTableFile, 100, 1);

  std::string tmp1, tmp2;
  ASSERT_OK(db_->Put(WriteOptions(), Key(1000, &tmp1), Value(1000, &tmp2)));
  std::string v;
  ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
  ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
  dbi->TEST_FlushMemTable();
  ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
  ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
}

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		ResetTimestamp
	)

Definition at line 363 of file ttl_test.cc.

                              {
  MakeKVMap(kSampleSize_);

  OpenTtl(3);
  PutValues(0, kSampleSize_);            // T=0: Insert Set1. Delete at t=3
  sleep(2);                             // T=2
  PutValues(0, kSampleSize_);            // T=2: Insert Set1. Delete at t=5
  SleepCompactCheck(2, 0, kSampleSize_); // T=4: Set1 should still be there
  CloseTtl();
}

rocksdb::TEST	(	EnvPosixTest	,
		PosixRandomRWFileTest
	)

Definition at line 371 of file env_test.cc.

References rocksdb::RandomRWFile::Allocate(), ASSERT_EQ, ASSERT_OK, rocksdb::RandomRWFile::Close(), rocksdb::Slice::compare(), env_, rocksdb::RandomRWFile::Fsync(), rocksdb::Env::NewRandomRWFile(), rocksdb::RandomRWFile::Read(), rocksdb::RandomRWFile::Sync(), rocksdb::test::TmpDir(), rocksdb::EnvOptions::use_mmap_reads, rocksdb::EnvOptions::use_mmap_writes, and rocksdb::RandomRWFile::Write().

                                          {
  EnvOptions soptions;
  soptions.use_mmap_writes = soptions.use_mmap_reads = false;
  std::string fname = test::TmpDir() + "/" + "testfile";

  unique_ptr<RandomRWFile> file;
  ASSERT_OK(env_->NewRandomRWFile(fname, &file, soptions));
  // If you run the unit test on tmpfs, then tmpfs might not
  // support fallocate. It is still better to trigger that
  // code-path instead of eliminating it completely.
  file.get()->Allocate(0, 10*1024*1024);
  ASSERT_OK(file.get()->Write(100, Slice("Hello world")));
  ASSERT_OK(file.get()->Write(105, Slice("Hello world")));
  ASSERT_OK(file.get()->Sync());
  ASSERT_OK(file.get()->Fsync());
  char scratch[100];
  Slice result;
  ASSERT_OK(file.get()->Read(100, 16, &result, scratch));
  ASSERT_EQ(result.compare("HelloHello world"), 0);
  ASSERT_OK(file.get()->Close());
}

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		Concurrent1
	)

Definition at line 373 of file skiplist_test.cc.

References RunConcurrent().

{ RunConcurrent(1); }

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		Concurrent2
	)

Definition at line 374 of file skiplist_test.cc.

References RunConcurrent().

{ RunConcurrent(2); }

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		IterPresentDuringTTL
	)

Definition at line 375 of file ttl_test.cc.

                                    {
  MakeKVMap(kSampleSize_);

  OpenTtl(2);
  PutValues(0, kSampleSize_);                 // T=0: Insert. Delete at t=2
  SleepCompactCheckIter(1, 0, kSampleSize_);  // T=1: Set should be there
  CloseTtl();
}

rocksdb::TEST	(	SkipTest	,
		Concurrent3
	)

Definition at line 375 of file skiplist_test.cc.

References RunConcurrent().

{ RunConcurrent(3); }

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		Concurrent4
	)

Definition at line 376 of file skiplist_test.cc.

References RunConcurrent().

{ RunConcurrent(4); }

Here is the call graph for this function:

rocksdb::TEST	(	SkipTest	,
		Concurrent5
	)

Definition at line 377 of file skiplist_test.cc.

References RunConcurrent().

{ RunConcurrent(5); }

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		IterAbsentAfterTTL
	)

Definition at line 385 of file ttl_test.cc.

                                  {
  MakeKVMap(kSampleSize_);

  OpenTtl(1);
  PutValues(0, kSampleSize_);                      // T=0: Insert. Delete at t=1
  SleepCompactCheckIter(2, 0, kSampleSize_, false); // T=2: Should not be there
  CloseTtl();
}

rocksdb::TEST	(	StringAppendOperatorTest	,
		PersistentVariousKeys
	)

Definition at line 390 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, db, rocksdb::StringLists::Get(), and OpenDb().

                                                      {
  // Perform the following operations in limited scope
  {
    auto db = OpenDb('\n');
    StringLists slists(db);

    slists.Append("c", "asdasd");
    slists.Append("a", "x");
    slists.Append("b", "y");
    slists.Append("a", "t");
    slists.Append("a", "r");
    slists.Append("b", "2");
    slists.Append("c", "asdasd");

    std::string a, b, c;
    slists.Get("a", &a);
    slists.Get("b", &b);
    slists.Get("c", &c);

    ASSERT_EQ(a, "x\nt\nr");
    ASSERT_EQ(b, "y\n2");
    ASSERT_EQ(c, "asdasd\nasdasd");
  }

  // Reopen the database (the previous changes should persist / be remembered)
  {
    auto db = OpenDb('\n');
    StringLists slists(db);

    slists.Append("c", "bbnagnagsx");
    slists.Append("a", "sa");
    slists.Append("b", "df");
    slists.Append("a", "gh");
    slists.Append("a", "jk");
    slists.Append("b", "l;");
    slists.Append("c", "rogosh");

    // The previous changes should be on disk (L0)
    // The most recent changes should be in memory (MemTable)
    // Hence, this will test both Get() paths.
    std::string a, b, c;
    slists.Get("a", &a);
    slists.Get("b", &b);
    slists.Get("c", &c);

    ASSERT_EQ(a, "x\nt\nr\nsa\ngh\njk");
    ASSERT_EQ(b, "y\n2\ndf\nl;");
    ASSERT_EQ(c, "asdasd\nasdasd\nbbnagnagsx\nrogosh");
  }

  // Reopen the database (the previous changes should persist / be remembered)
  {
    auto db = OpenDb('\n');
    StringLists slists(db);

    // All changes should be on disk. This will test VersionSet Get()
    std::string a, b, c;
    slists.Get("a", &a);
    slists.Get("b", &b);
    slists.Get("c", &c);

    ASSERT_EQ(a, "x\nt\nr\nsa\ngh\njk");
    ASSERT_EQ(b, "y\n2\ndf\nl;");
    ASSERT_EQ(c, "asdasd\nasdasd\nbbnagnagsx\nrogosh");
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		MultiOpenSamePresent
	)

Definition at line 396 of file ttl_test.cc.

                                    {
  MakeKVMap(kSampleSize_);

  OpenTtl(2);
  PutValues(0, kSampleSize_);                   // T=0: Insert. Delete at t=2
  CloseTtl();

  OpenTtl(2);                                  // T=0. Delete at t=2
  SleepCompactCheck(1, 0, kSampleSize_);        // T=1: Set should be there
  CloseTtl();
}

rocksdb::TEST	(	TtlTest	,
		MultiOpenSameAbsent
	)

Definition at line 410 of file ttl_test.cc.

                                   {
  MakeKVMap(kSampleSize_);

  OpenTtl(1);
  PutValues(0, kSampleSize_);                   // T=0: Insert. Delete at t=1
  CloseTtl();

  OpenTtl(1);                                  // T=0.Delete at t=1
  SleepCompactCheck(2, 0, kSampleSize_, false); // T=2: Set should not be there
  CloseTtl();
}

rocksdb::TEST	(	TtlTest	,
		MultiOpenDifferent
	)

Definition at line 423 of file ttl_test.cc.

                                  {
  MakeKVMap(kSampleSize_);

  OpenTtl(1);
  PutValues(0, kSampleSize_);            // T=0: Insert. Delete at t=1
  CloseTtl();

  OpenTtl(3);                           // T=0: Set deleted at t=3
  SleepCompactCheck(2, 0, kSampleSize_); // T=2: Set should be there
  CloseTtl();
}

rocksdb::TEST	(	RedisListsTest	,
		InsertPushSetTest
	)

Definition at line 433 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::InsertAfter(), rocksdb::RedisLists::InsertBefore(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PushLeft(), rocksdb::RedisLists::PushRight(), rocksdb::RedisLists::Range(), and rocksdb::RedisLists::Set().

                                        {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // A series of pushes and insertions
  // Will result in [newbegin, z, a, aftera, x, newend]
  // Also, check the return value sometimes (should return length)
  int lengthCheck;
  lengthCheck = redis.PushLeft("k1", "a");
  ASSERT_EQ(lengthCheck, 1);
  redis.PushLeft("k1", "z");
  redis.PushRight("k1", "x");
  lengthCheck = redis.InsertAfter("k1", "a", "aftera");
  ASSERT_EQ(lengthCheck , 4);
  redis.InsertBefore("k1", "z", "newbegin");  // InsertBefore beginning of list
  redis.InsertAfter("k1", "x", "newend");     // InsertAfter end of list

  // Check
  std::vector<std::string> res = redis.Range("k1", 0, -1); // Get the list
  ASSERT_EQ((int)res.size(), 6);
  ASSERT_EQ(res[0], "newbegin");
  ASSERT_EQ(res[5], "newend");
  ASSERT_EQ(res[3], "aftera");

  // Testing duplicate values/pivots (multiple occurrences of 'a')
  ASSERT_TRUE(redis.Set("k1", 0, "a"));     // [a, z, a, aftera, x, newend]
  redis.InsertAfter("k1", "a", "happy");    // [a, happy, z, a, aftera, ...]
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "happy");
  redis.InsertBefore("k1", "a", "sad");     // [sad, a, happy, z, a, aftera, ...]
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "sad");
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "happy");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "aftera");
  redis.InsertAfter("k1", "a", "zz");         // [sad, a, zz, happy, z, a, aftera, ...]
  ASSERT_TRUE(redis.Index("k1", 2, &tempv));
  ASSERT_EQ(tempv, "zz");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "aftera");
  ASSERT_TRUE(redis.Set("k1", 1, "nota"));    // [sad, nota, zz, happy, z, a, ...]
  redis.InsertBefore("k1", "a", "ba");        // [sad, nota, zz, happy, z, ba, a, ...]
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "z");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "ba");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "a");

  // We currently have: [sad, nota, zz, happy, z, ba, a, aftera, x, newend]
  // redis.Print("k1");   // manually check

  // Test Inserting before/after non-existent values
  lengthCheck = redis.Length("k1"); // Ensure that the length doesn't change
  ASSERT_EQ(lengthCheck, 10);
  ASSERT_EQ(redis.InsertBefore("k1", "non-exist", "randval"), lengthCheck);
  ASSERT_EQ(redis.InsertAfter("k1", "nothing", "a"), lengthCheck);
  ASSERT_EQ(redis.InsertAfter("randKey", "randVal", "ranValue"), 0); // Empty
  ASSERT_EQ(redis.Length("k1"), lengthCheck); // The length should not change

  // Simply Test the Set() function
  redis.Set("k1", 5, "ba2");
  redis.InsertBefore("k1", "ba2", "beforeba2");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "z");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "beforeba2");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "ba2");
  ASSERT_TRUE(redis.Index("k1", 7, &tempv));
  ASSERT_EQ(tempv, "a");

  // We have: [sad, nota, zz, happy, z, beforeba2, ba2, a, aftera, x, newend]

  // Set() with negative indices
  redis.Set("k1", -1, "endprank");
  ASSERT_TRUE(!redis.Index("k1", 11, &tempv));
  ASSERT_TRUE(redis.Index("k1", 10, &tempv));
  ASSERT_EQ(tempv, "endprank"); // Ensure Set worked correctly
  redis.Set("k1", -11, "t");
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "t");

  // Test out of bounds Set
  ASSERT_EQ(redis.Set("k1", -12, "ssd"), false);
  ASSERT_EQ(redis.Set("k1", 11, "sasd"), false);
  ASSERT_EQ(redis.Set("k1", 1200, "big"), false);
}

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		ReadOnlyPresentForever
	)

Definition at line 436 of file ttl_test.cc.

                                      {
  MakeKVMap(kSampleSize_);

  OpenTtl(1);                                 // T=0:Open the db normally
  PutValues(0, kSampleSize_);                  // T=0:Insert Set1. Delete at t=1
  CloseTtl();

  OpenReadOnlyTtl(1);
  SleepCompactCheck(2, 0, kSampleSize_);       // T=2:Set1 should still be there
  CloseTtl();
}

rocksdb::TEST	(	TtlTest	,
		WriteBatchTest
	)

Definition at line 450 of file ttl_test.cc.

                              {
  MakeKVMap(kSampleSize_);
  BatchOperation batch_ops[kSampleSize_];
  for (int i = 0; i < kSampleSize_; i++) {
    batch_ops[i] = PUT;
  }

  OpenTtl(2);
  MakePutWriteBatch(batch_ops, kSampleSize_);
  for (int i = 0; i < kSampleSize_ / 2; i++) {
    batch_ops[i] = DELETE;
  }
  MakePutWriteBatch(batch_ops, kSampleSize_ / 2);
  SleepCompactCheck(0, 0, kSampleSize_ / 2, false);
  SleepCompactCheck(0, kSampleSize_ / 2, kSampleSize_ - kSampleSize_ / 2);
  CloseTtl();
}

rocksdb::TEST	(	StringAppendOperatorTest	,
		PersistentFlushAndCompaction
	)

Definition at line 457 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, ASSERT_TRUE, rocksdb::DBImpl::CompactRange(), db, rocksdb::DBImpl::Flush(), rocksdb::StringLists::Get(), and OpenDb().

                                                             {
  // Perform the following operations in limited scope
  {
    auto db = OpenDb('\n');
    StringLists slists(db);
    std::string a, b, c;
    bool success;

    // Append, Flush, Get
    slists.Append("c", "asdasd");
    db->Flush(rocksdb::FlushOptions());
    success = slists.Get("c", &c);
    ASSERT_TRUE(success);
    ASSERT_EQ(c, "asdasd");

    // Append, Flush, Append, Get
    slists.Append("a", "x");
    slists.Append("b", "y");
    db->Flush(rocksdb::FlushOptions());
    slists.Append("a", "t");
    slists.Append("a", "r");
    slists.Append("b", "2");

    success = slists.Get("a", &a);
    assert(success == true);
    ASSERT_EQ(a, "x\nt\nr");

    success = slists.Get("b", &b);
    assert(success == true);
    ASSERT_EQ(b, "y\n2");

    // Append, Get
    success = slists.Append("c", "asdasd");
    assert(success);
    success = slists.Append("b", "monkey");
    assert(success);

    // I omit the "assert(success)" checks here.
    slists.Get("a", &a);
    slists.Get("b", &b);
    slists.Get("c", &c);

    ASSERT_EQ(a, "x\nt\nr");
    ASSERT_EQ(b, "y\n2\nmonkey");
    ASSERT_EQ(c, "asdasd\nasdasd");
  }

  // Reopen the database (the previous changes should persist / be remembered)
  {
    auto db = OpenDb('\n');
    StringLists slists(db);
    std::string a, b, c;

    // Get (Quick check for persistence of previous database)
    slists.Get("a", &a);
    ASSERT_EQ(a, "x\nt\nr");

    //Append, Compact, Get
    slists.Append("c", "bbnagnagsx");
    slists.Append("a", "sa");
    slists.Append("b", "df");
    db->CompactRange(nullptr, nullptr);
    slists.Get("a", &a);
    slists.Get("b", &b);
    slists.Get("c", &c);
    ASSERT_EQ(a, "x\nt\nr\nsa");
    ASSERT_EQ(b, "y\n2\nmonkey\ndf");
    ASSERT_EQ(c, "asdasd\nasdasd\nbbnagnagsx");

    // Append, Get
    slists.Append("a", "gh");
    slists.Append("a", "jk");
    slists.Append("b", "l;");
    slists.Append("c", "rogosh");
    slists.Get("a", &a);
    slists.Get("b", &b);
    slists.Get("c", &c);
    ASSERT_EQ(a, "x\nt\nr\nsa\ngh\njk");
    ASSERT_EQ(b, "y\n2\nmonkey\ndf\nl;");
    ASSERT_EQ(c, "asdasd\nasdasd\nbbnagnagsx\nrogosh");

    // Compact, Get
    db->CompactRange(nullptr, nullptr);
    ASSERT_EQ(a, "x\nt\nr\nsa\ngh\njk");
    ASSERT_EQ(b, "y\n2\nmonkey\ndf\nl;");
    ASSERT_EQ(c, "asdasd\nasdasd\nbbnagnagsx\nrogosh");

    // Append, Flush, Compact, Get
    slists.Append("b", "afcg");
    db->Flush(rocksdb::FlushOptions());
    db->CompactRange(nullptr, nullptr);
    slists.Get("b", &b);
    ASSERT_EQ(b, "y\n2\nmonkey\ndf\nl;\nafcg");
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	TtlTest	,
		CompactionFilter
	)

Definition at line 469 of file ttl_test.cc.

                                {
  MakeKVMap(kSampleSize_);

  OpenTtlWithTestCompaction(1);
  PutValues(0, kSampleSize_);                  // T=0:Insert Set1. Delete at t=1
  // T=2: TTL logic takes precedence over TestFilter:-Set1 should not be there
  SleepCompactCheck(2, 0, kSampleSize_, false);
  CloseTtl();

  OpenTtlWithTestCompaction(3);
  PutValues(0, kSampleSize_);                   // T=0:Insert Set1.
  int partition = kSampleSize_ / 3;
  SleepCompactCheck(1, 0, partition, false);   // Part dropped
  SleepCompactCheck(0, partition, partition);  // Part kept
  SleepCompactCheck(0, 2 * partition, partition, true, true); // Part changed
  CloseTtl();
}

rocksdb::TEST	(	TtlTest	,
		KeyMayExist
	)

Definition at line 489 of file ttl_test.cc.

                           {
  MakeKVMap(kSampleSize_);

  OpenTtl();
  PutValues(0, kSampleSize_, false);

  SimpleKeyMayExistCheck();

  CloseTtl();
}

rocksdb::TEST	(	RedisListsTest	,
		TrimPopTest
	)

Definition at line 525 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::InsertAfter(), rocksdb::RedisLists::InsertBefore(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PopLeft(), rocksdb::RedisLists::PopRight(), rocksdb::RedisLists::PushLeft(), rocksdb::RedisLists::PushRight(), and rocksdb::RedisLists::Trim().

                                  {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // A series of pushes and insertions
  // Will result in [newbegin, z, a, aftera, x, newend]
  redis.PushLeft("k1", "a");
  redis.PushLeft("k1", "z");
  redis.PushRight("k1", "x");
  redis.InsertBefore("k1", "z", "newbegin");    // InsertBefore start of list
  redis.InsertAfter("k1", "x", "newend");       // InsertAfter end of list
  redis.InsertAfter("k1", "a", "aftera");

  // Simple PopLeft/Right test
  ASSERT_TRUE(redis.PopLeft("k1", &tempv));
  ASSERT_EQ(tempv, "newbegin");
  ASSERT_EQ(redis.Length("k1"), 5);
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "z");
  ASSERT_TRUE(redis.PopRight("k1", &tempv));
  ASSERT_EQ(tempv, "newend");
  ASSERT_EQ(redis.Length("k1"), 4);
  ASSERT_TRUE(redis.Index("k1", -1, &tempv));
  ASSERT_EQ(tempv, "x");

  // Now have: [z, a, aftera, x]

  // Test Trim
  ASSERT_TRUE(redis.Trim("k1", 0, -1));       // [z, a, aftera, x] (do nothing)
  ASSERT_EQ(redis.Length("k1"), 4);
  ASSERT_TRUE(redis.Trim("k1", 0, 2));                     // [z, a, aftera]
  ASSERT_EQ(redis.Length("k1"), 3);
  ASSERT_TRUE(redis.Index("k1", -1, &tempv));
  ASSERT_EQ(tempv, "aftera");
  ASSERT_TRUE(redis.Trim("k1", 1, 1));                     // [a]
  ASSERT_EQ(redis.Length("k1"), 1);
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "a");

  // Test out of bounds (empty) trim
  ASSERT_TRUE(redis.Trim("k1", 1, 0));
  ASSERT_EQ(redis.Length("k1"), 0);

  // Popping with empty list (return empty without error)
  ASSERT_TRUE(!redis.PopLeft("k1", &tempv));
  ASSERT_TRUE(!redis.PopRight("k1", &tempv));
  ASSERT_TRUE(redis.Trim("k1", 0, 5));

  // Exhaustive Trim test (negative and invalid indices)
  // Will start in [newbegin, z, a, aftera, x, newend]
  redis.PushLeft("k1", "a");
  redis.PushLeft("k1", "z");
  redis.PushRight("k1", "x");
  redis.InsertBefore("k1", "z", "newbegin");    // InsertBefore start of list
  redis.InsertAfter("k1", "x", "newend");       // InsertAfter end of list
  redis.InsertAfter("k1", "a", "aftera");
  ASSERT_TRUE(redis.Trim("k1", -6, -1));                     // Should do nothing
  ASSERT_EQ(redis.Length("k1"), 6);
  ASSERT_TRUE(redis.Trim("k1", 1, -2));
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "z");
  ASSERT_TRUE(redis.Index("k1", 3, &tempv));
  ASSERT_EQ(tempv, "x");
  ASSERT_EQ(redis.Length("k1"), 4);
  ASSERT_TRUE(redis.Trim("k1", -3, -2));
  ASSERT_EQ(redis.Length("k1"), 2);
}

Here is the call graph for this function:

rocksdb::TEST	(	StringAppendOperatorTest	,
		SimpleTestNullDelimiter
	)

Definition at line 553 of file stringappend_test.cc.

References rocksdb::StringLists::Append(), ASSERT_EQ, ASSERT_TRUE, db, rocksdb::StringLists::Get(), and OpenDb().

                                                        {
  auto db = OpenDb('\0');
  StringLists slists(db);

  slists.Append("k1", "v1");
  slists.Append("k1", "v2");
  slists.Append("k1", "v3");

  std::string res;
  bool status = slists.Get("k1", &res);
  ASSERT_TRUE(status);

  // Construct the desired string. Default constructor doesn't like '\0' chars.
  std::string checker("v1,v2,v3");    // Verify that the string is right size.
  checker[2] = '\0';                  // Use null delimiter instead of comma.
  checker[5] = '\0';
  assert(checker.size() == 8);        // Verify it is still the correct size

  // Check that the rocksdb result string matches the desired string
  assert(res.size() == checker.size());
  ASSERT_EQ(res, checker);
}

Here is the call graph for this function:

rocksdb::TEST	(	RedisListsTest	,
		RemoveTest
	)

Definition at line 595 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::InsertAfter(), rocksdb::RedisLists::InsertBefore(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PushLeft(), rocksdb::RedisLists::PushRight(), rocksdb::RedisLists::Remove(), and rocksdb::RedisLists::Trim().

                                 {
  RedisLists redis(kDefaultDbName, options, true);   // Destructive

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // A series of pushes and insertions
  // Will result in [newbegin, z, a, aftera, x, newend, a, a]
  redis.PushLeft("k1", "a");
  redis.PushLeft("k1", "z");
  redis.PushRight("k1", "x");
  redis.InsertBefore("k1", "z", "newbegin");    // InsertBefore start of list
  redis.InsertAfter("k1", "x", "newend");       // InsertAfter end of list
  redis.InsertAfter("k1", "a", "aftera");
  redis.PushRight("k1", "a");
  redis.PushRight("k1", "a");

  // Verify
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "newbegin");
  ASSERT_TRUE(redis.Index("k1", -1, &tempv));
  ASSERT_EQ(tempv, "a");

  // Check RemoveFirst (Remove the first two 'a')
  // Results in [newbegin, z, aftera, x, newend, a]
  int numRemoved = redis.Remove("k1", 2, "a");
  ASSERT_EQ(numRemoved, 2);
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "newbegin");
  ASSERT_TRUE(redis.Index("k1", 1, &tempv));
  ASSERT_EQ(tempv, "z");
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "newend");
  ASSERT_TRUE(redis.Index("k1", 5, &tempv));
  ASSERT_EQ(tempv, "a");
  ASSERT_EQ(redis.Length("k1"), 6);

  // Repopulate some stuff
  // Results in: [x, x, x, x, x, newbegin, z, x, aftera, x, newend, a, x]
  redis.PushLeft("k1", "x");
  redis.PushLeft("k1", "x");
  redis.PushLeft("k1", "x");
  redis.PushLeft("k1", "x");
  redis.PushLeft("k1", "x");
  redis.PushRight("k1", "x");
  redis.InsertAfter("k1", "z", "x");

  // Test removal from end
  numRemoved = redis.Remove("k1", -2, "x");
  ASSERT_EQ(numRemoved, 2);
  ASSERT_TRUE(redis.Index("k1", 8, &tempv));
  ASSERT_EQ(tempv, "aftera");
  ASSERT_TRUE(redis.Index("k1", 9, &tempv));
  ASSERT_EQ(tempv, "newend");
  ASSERT_TRUE(redis.Index("k1", 10, &tempv));
  ASSERT_EQ(tempv, "a");
  ASSERT_TRUE(!redis.Index("k1", 11, &tempv));
  numRemoved = redis.Remove("k1", -2, "x");
  ASSERT_EQ(numRemoved, 2);
  ASSERT_TRUE(redis.Index("k1", 4, &tempv));
  ASSERT_EQ(tempv, "newbegin");
  ASSERT_TRUE(redis.Index("k1", 6, &tempv));
  ASSERT_EQ(tempv, "aftera");

  // We now have: [x, x, x, x, newbegin, z, aftera, newend, a]
  ASSERT_EQ(redis.Length("k1"), 9);
  ASSERT_TRUE(redis.Index("k1", -1, &tempv));
  ASSERT_EQ(tempv, "a");
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "x");

  // Test over-shooting (removing more than there exists)
  numRemoved = redis.Remove("k1", -9000, "x");
  ASSERT_EQ(numRemoved , 4);    // Only really removed 4
  ASSERT_EQ(redis.Length("k1"), 5);
  ASSERT_TRUE(redis.Index("k1", 0, &tempv));
  ASSERT_EQ(tempv, "newbegin");
  numRemoved = redis.Remove("k1", 1, "x");
  ASSERT_EQ(numRemoved, 0);

  // Try removing ALL!
  numRemoved = redis.Remove("k1", 0, "newbegin");   // REMOVE 0 will remove all!
  ASSERT_EQ(numRemoved, 1);

  // Removal from an empty-list
  ASSERT_TRUE(redis.Trim("k1", 1, 0));
  numRemoved = redis.Remove("k1", 1, "z");
  ASSERT_EQ(numRemoved, 0);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		Empty
	)

Definition at line 684 of file db_test.cc.

References ASSERT_EQ, ASSERT_TRUE, and db_.

                    {
  do {
    ASSERT_TRUE(db_ != nullptr);
    ASSERT_EQ("NOT_FOUND", Get("foo"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	RedisListsTest	,
		PersistenceMultiKeyTest
	)

Definition at line 686 of file redis_lists_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::RedisLists::Index(), rocksdb::RedisLists::InsertAfter(), rocksdb::RedisLists::InsertBefore(), rocksdb::RedisLists::Length(), rocksdb::RedisLists::PopLeft(), rocksdb::RedisLists::PushLeft(), and rocksdb::RedisLists::PushRight().

                                              {

  string tempv; // Used below for all Index(), PopRight(), PopLeft()

  // Block one: populate a single key in the database
  {
    RedisLists redis(kDefaultDbName, options, true);   // Destructive

    // A series of pushes and insertions
    // Will result in [newbegin, z, a, aftera, x, newend, a, a]
    redis.PushLeft("k1", "a");
    redis.PushLeft("k1", "z");
    redis.PushRight("k1", "x");
    redis.InsertBefore("k1", "z", "newbegin");    // InsertBefore start of list
    redis.InsertAfter("k1", "x", "newend");       // InsertAfter end of list
    redis.InsertAfter("k1", "a", "aftera");
    redis.PushRight("k1", "a");
    redis.PushRight("k1", "a");

    ASSERT_TRUE(redis.Index("k1", 3, &tempv));
    ASSERT_EQ(tempv, "aftera");
  }

  // Block two: make sure changes were saved and add some other key
  {
    RedisLists redis(kDefaultDbName, options, false); // Persistent, non-destructive

    // Check
    ASSERT_EQ(redis.Length("k1"), 8);
    ASSERT_TRUE(redis.Index("k1", 3, &tempv));
    ASSERT_EQ(tempv, "aftera");

    redis.PushRight("k2", "randomkey");
    redis.PushLeft("k2", "sas");

    redis.PopLeft("k1", &tempv);
  }

  // Block three: Verify the changes from block 2
  {
    RedisLists redis(kDefaultDbName, options, false); // Persistent, non-destructive

    // Check
    ASSERT_EQ(redis.Length("k1"), 7);
    ASSERT_EQ(redis.Length("k2"), 2);
    ASSERT_TRUE(redis.Index("k1", 0, &tempv));
    ASSERT_EQ(tempv, "z");
    ASSERT_TRUE(redis.Index("k2", -2, &tempv));
    ASSERT_EQ(tempv, "sas");
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ReadWrite
	)

Definition at line 691 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                        {
  do {
    ASSERT_OK(Put("foo", "v1"));
    ASSERT_EQ("v1", Get("foo"));
    ASSERT_OK(Put("bar", "v2"));
    ASSERT_OK(Put("foo", "v3"));
    ASSERT_EQ("v3", Get("foo"));
    ASSERT_EQ("v2", Get("bar"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	SimpleTableDBTest	,
		Empty
	)

Definition at line 698 of file simple_table_db_test.cc.

References ASSERT_EQ, ASSERT_TRUE, and db_.

                               {
  ASSERT_TRUE(db_ != nullptr);
  ASSERT_EQ("NOT_FOUND", Get("0000000000000foo"));
}

rocksdb::TEST	(	SimpleTableDBTest	,
		ReadWrite
	)

Definition at line 703 of file simple_table_db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                   {
  ASSERT_OK(Put("0000000000000foo", "v1"));
  ASSERT_EQ("v1", Get("0000000000000foo"));
  ASSERT_OK(Put("0000000000000bar", "v2"));
  ASSERT_OK(Put("0000000000000foo", "v3"));
  ASSERT_EQ("v3", Get("0000000000000foo"));
  ASSERT_EQ("v2", Get("0000000000000bar"));
}

rocksdb::TEST	(	DBTest	,
		IndexAndFilterBlocksOfNewTableAddedToCache
	)

Definition at line 704 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, BLOCK_CACHE_ADD, BLOCK_CACHE_DATA_MISS, BLOCK_CACHE_FILTER_HIT, BLOCK_CACHE_FILTER_MISS, BLOCK_CACHE_INDEX_MISS, rocksdb::Options::create_if_missing, CreateDBStatistics(), db_, rocksdb::Options::filter_policy, rocksdb::DBImpl::KeyMayExist(), NewBloomFilterPolicy(), rocksdb::DBImpl::Put(), rocksdb::Options::statistics, and value.

                                                         {
  Options options = CurrentOptions();
  std::unique_ptr<const FilterPolicy> filter_policy(NewBloomFilterPolicy(20));
  options.filter_policy = filter_policy.get();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  DestroyAndReopen(&options);

  ASSERT_OK(db_->Put(WriteOptions(), "key", "val"));
  // Create a new talbe.
  dbfull()->Flush(FlushOptions());

  // index/filter blocks added to block cache right after table creation.
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_INDEX_MISS));
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(2, /* only index/filter were added */
            options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));
  ASSERT_EQ(0,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_DATA_MISS));

  // Make sure filter block is in cache.
  std::string value;
  ReadOptions ropt;
  db_->KeyMayExist(ReadOptions(), "key", &value);

  // Miss count should remain the same.
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_HIT));

  db_->KeyMayExist(ReadOptions(), "key", &value);
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(2,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_HIT));

  // Make sure index block is in cache.
  auto index_block_hit =
    options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_HIT);
  value = Get("key");
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(index_block_hit + 1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_HIT));

  value = Get("key");
  ASSERT_EQ(1,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(index_block_hit + 2,
            options.statistics.get()->getTickerCount(BLOCK_CACHE_FILTER_HIT));
}

Here is the call graph for this function:

rocksdb::TEST	(	SimpleTableDBTest	,
		Flush
	)

Definition at line 712 of file simple_table_db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                               {
  ASSERT_OK(Put("0000000000000foo", "v1"));
  ASSERT_OK(Put("0000000000000bar", "v2"));
  ASSERT_OK(Put("0000000000000foo", "v3"));
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ("v3", Get("0000000000000foo"));
  ASSERT_EQ("v2", Get("0000000000000bar"));
}

rocksdb::TEST	(	SimpleTableDBTest	,
		Flush2
	)

Definition at line 721 of file simple_table_db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                {
  ASSERT_OK(Put("0000000000000bar", "b"));
  ASSERT_OK(Put("0000000000000foo", "v1"));
  dbfull()->TEST_FlushMemTable();

  ASSERT_OK(Put("0000000000000foo", "v2"));
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ("v2", Get("0000000000000foo"));

  ASSERT_OK(Put("0000000000000eee", "v3"));
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ("v3", Get("0000000000000eee"));

  ASSERT_OK(Delete("0000000000000bar"));
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ("NOT_FOUND", Get("0000000000000bar"));

  ASSERT_OK(Put("0000000000000eee", "v5"));
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ("v5", Get("0000000000000eee"));
}

rocksdb::TEST	(	Harness	,
		SimpleEmptyKey
	)

Definition at line 747 of file table_test.cc.

References GenerateArgList(), and rocksdb::test::RandomSeed().

                              {
  std::vector<TestArgs> args = GenerateArgList();
  for (unsigned int i = 0; i < args.size(); i++) {
    Init(args[i]);
    Random rnd(test::RandomSeed() + 1);
    Add("", "v");
    Test(&rnd);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	SimpleTableDBTest	,
		CompactionTrigger
	)

Definition at line 755 of file simple_table_db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::level0_file_num_compaction_trigger, rocksdb::Options::max_mem_compaction_level, rocksdb::Options::num_levels, RandomString(), and rocksdb::Options::write_buffer_size.

                                           {
  Options options = CurrentOptions();
  options.write_buffer_size = 100 << 10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
  Reopen(&options);

  Random rnd(301);

  for (int num = 0; num < options.level0_file_num_compaction_trigger - 1;
      num++) {
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      values.push_back(RandomString(&rnd, 10000));
      ASSERT_OK(Put(Key(i), values[i]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(NumTableFilesAtLevel(0), num + 1);
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
    values.push_back(RandomString(&rnd, 10000));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
}

Here is the call graph for this function:

rocksdb::TEST	(	Harness	,
		SimpleSingle
	)

Definition at line 757 of file table_test.cc.

References GenerateArgList(), and rocksdb::test::RandomSeed().

                            {
  std::vector<TestArgs> args = GenerateArgList();
  for (unsigned int i = 0; i < args.size(); i++) {
    Init(args[i]);
    Random rnd(test::RandomSeed() + 2);
    Add("abc", "v");
    Test(&rnd);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		LevelLimitReopen
	)

Definition at line 759 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Status::IsCorruption(), rocksdb::Options::max_bytes_for_level_multiplier_additional, rocksdb::Options::num_levels, rocksdb::Status::ToString(), and value.

                               {
  Options options = CurrentOptions();
  Reopen(&options);

  const std::string value(1024 * 1024, ' ');
  int i = 0;
  while (NumTableFilesAtLevel(2) == 0) {
    ASSERT_OK(Put(Key(i++), value));
  }

  options.num_levels = 1;
  options.max_bytes_for_level_multiplier_additional.resize(1, 1);
  Status s = TryReopen(&options);
  ASSERT_EQ(s.IsCorruption(), true);
  ASSERT_EQ(s.ToString(),
            "Corruption: VersionEdit: db already has "
            "more levels than options.num_levels");

  options.num_levels = 10;
  options.max_bytes_for_level_multiplier_additional.resize(10, 1);
  ASSERT_OK(TryReopen(&options));
}

Here is the call graph for this function:

rocksdb::TEST	(	Harness	,
		SimpleMulti
	)

Definition at line 767 of file table_test.cc.

References GenerateArgList(), and rocksdb::test::RandomSeed().

                           {
  std::vector<TestArgs> args = GenerateArgList();
  for (unsigned int i = 0; i < args.size(); i++) {
    Init(args[i]);
    Random rnd(test::RandomSeed() + 3);
    Add("abc", "v");
    Add("abcd", "v");
    Add("ac", "v2");
    Test(&rnd);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	Harness	,
		SimpleSpecialKey
	)

Definition at line 779 of file table_test.cc.

References GenerateArgList(), and rocksdb::test::RandomSeed().

                                {
  std::vector<TestArgs> args = GenerateArgList();
  for (unsigned int i = 0; i < args.size(); i++) {
    Init(args[i]);
    Random rnd(test::RandomSeed() + 4);
    Add("\xff\xff", "v3");
    Test(&rnd);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		Preallocation
	)

Definition at line 782 of file db_test.cc.

References rocksdb::WritableFile::Append(), ASSERT_EQ, ASSERT_OK, dbname_, env_, rocksdb::WritableFile::GetPreallocationStatus(), rocksdb::Env::NewWritableFile(), and rocksdb::WritableFile::SetPreallocationBlockSize().

                            {
  const std::string src = dbname_ + "/alloc_test";
  unique_ptr<WritableFile> srcfile;
  const EnvOptions soptions;
  ASSERT_OK(env_->NewWritableFile(src, &srcfile, soptions));
  srcfile->SetPreallocationBlockSize(1024 * 1024);

  // No writes should mean no preallocation
  size_t block_size, last_allocated_block;
  srcfile->GetPreallocationStatus(&block_size, &last_allocated_block);
  ASSERT_EQ(last_allocated_block, 0UL);

  // Small write should preallocate one block
  srcfile->Append("test");
  srcfile->GetPreallocationStatus(&block_size, &last_allocated_block);
  ASSERT_EQ(last_allocated_block, 1UL);

  // Write an entire preallocation block, make sure we increased by two.
  std::string buf(block_size, ' ');
  srcfile->Append(buf);
  srcfile->GetPreallocationStatus(&block_size, &last_allocated_block);
  ASSERT_EQ(last_allocated_block, 2UL);

  // Write five more blocks at once, ensure we're where we need to be.
  buf = std::string(block_size * 5, ' ');
  srcfile->Append(buf);
  srcfile->GetPreallocationStatus(&block_size, &last_allocated_block);
  ASSERT_EQ(last_allocated_block, 7UL);
}

Here is the call graph for this function:

rocksdb::TEST	(	TableTest	,
		BasicTableProperties
	)

Definition at line 804 of file table_test.cc.

References rocksdb::BlockBuilder::Add(), rocksdb::Constructor::Add(), ASSERT_EQ, rocksdb::Options::block_restart_interval, BytewiseComparator(), rocksdb::Options::compression, rocksdb::BlockBuilder::Finish(), rocksdb::Constructor::Finish(), rocksdb::TableReader::GetTableProperties(), kBlockTrailerSize, kNoCompression, rocksdb::Slice::size(), and rocksdb::BlockBasedTableConstructor::table_reader().

                                      {
  BlockBasedTableConstructor c(BytewiseComparator());

  c.Add("a1", "val1");
  c.Add("b2", "val2");
  c.Add("c3", "val3");
  c.Add("d4", "val4");
  c.Add("e5", "val5");
  c.Add("f6", "val6");
  c.Add("g7", "val7");
  c.Add("h8", "val8");
  c.Add("j9", "val9");

  std::vector<std::string> keys;
  KVMap kvmap;
  Options options;
  options.compression = kNoCompression;
  options.block_restart_interval = 1;

  c.Finish(options, &keys, &kvmap);

  auto& props = c.table_reader()->GetTableProperties();
  ASSERT_EQ(kvmap.size(), props.num_entries);

  auto raw_key_size = kvmap.size() * 2ul;
  auto raw_value_size = kvmap.size() * 4ul;

  ASSERT_EQ(raw_key_size, props.raw_key_size);
  ASSERT_EQ(raw_value_size, props.raw_value_size);
  ASSERT_EQ(1ul, props.num_data_blocks);
  ASSERT_EQ("", props.filter_policy_name);  // no filter policy is used

  // Verify data size.
  BlockBuilder block_builder(options);
  for (const auto& item : kvmap) {
    block_builder.Add(item.first, item.second);
  }
  Slice content = block_builder.Finish();
  ASSERT_EQ(
      content.size() + kBlockTrailerSize,
      props.data_size
  );
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		PutDeleteGet
	)

Definition at line 812 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::Delete(), and rocksdb::DBImpl::Put().

                           {
  do {
    ASSERT_OK(db_->Put(WriteOptions(), "foo", "v1"));
    ASSERT_EQ("v1", Get("foo"));
    ASSERT_OK(db_->Put(WriteOptions(), "foo", "v2"));
    ASSERT_EQ("v2", Get("foo"));
    ASSERT_OK(db_->Delete(WriteOptions(), "foo"));
    ASSERT_EQ("NOT_FOUND", Get("foo"));
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		GetFromImmutableLayer
	)

Definition at line 824 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::env, env_, and rocksdb::Options::write_buffer_size.

                                    {
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
    Reopen(&options);

    ASSERT_OK(Put("foo", "v1"));
    ASSERT_EQ("v1", Get("foo"));

    env_->delay_sstable_sync_.Release_Store(env_);   // Block sync calls
    Put("k1", std::string(100000, 'x'));             // Fill memtable
    Put("k2", std::string(100000, 'y'));             // Trigger compaction
    ASSERT_EQ("v1", Get("foo"));
    env_->delay_sstable_sync_.Release_Store(nullptr);   // Release sync calls
  } while (ChangeOptions());
}

rocksdb::TEST	(	DBTest	,
		GetFromVersions
	)

Definition at line 842 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                              {
  do {
    ASSERT_OK(Put("foo", "v1"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("v1", Get("foo"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	TableTest	,
		FilterPolicyNameProperties
	)

Definition at line 848 of file table_test.cc.

References rocksdb::Constructor::Add(), ASSERT_EQ, BytewiseComparator(), rocksdb::Options::filter_policy, rocksdb::Constructor::Finish(), rocksdb::TableReader::GetTableProperties(), NewBloomFilterPolicy(), and rocksdb::BlockBasedTableConstructor::table_reader().

                                            {
  BlockBasedTableConstructor c(BytewiseComparator());
  c.Add("a1", "val1");
  std::vector<std::string> keys;
  KVMap kvmap;
  Options options;
  std::unique_ptr<const FilterPolicy> filter_policy(
    NewBloomFilterPolicy(10)
  );
  options.filter_policy = filter_policy.get();

  c.Finish(options, &keys, &kvmap);
  auto& props = c.table_reader()->GetTableProperties();
  ASSERT_EQ("rocksdb.BuiltinBloomFilter", props.filter_policy_name);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		GetSnapshot
	)

Definition at line 850 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::GetSnapshot(), and rocksdb::DBImpl::ReleaseSnapshot().

                          {
  do {
    // Try with both a short key and a long key
    for (int i = 0; i < 2; i++) {
      std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
      ASSERT_OK(Put(key, "v1"));
      const Snapshot* s1 = db_->GetSnapshot();
      ASSERT_OK(Put(key, "v2"));
      ASSERT_EQ("v2", Get(key));
      ASSERT_EQ("v1", Get(key, s1));
      dbfull()->TEST_FlushMemTable();
      ASSERT_EQ("v2", Get(key));
      ASSERT_EQ("v1", Get(key, s1));
      db_->ReleaseSnapshot(s1);
    }
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		GetLevel0Ordering
	)

Definition at line 868 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                {
  do {
    // Check that we process level-0 files in correct order.  The code
    // below generates two level-0 files where the earlier one comes
    // before the later one in the level-0 file list since the earlier
    // one has a smaller "smallest" key.
    ASSERT_OK(Put("bar", "b"));
    ASSERT_OK(Put("foo", "v1"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_OK(Put("foo", "v2"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("v2", Get("foo"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	TableTest	,
		IndexSizeStat
	)

Definition at line 873 of file table_test.cc.

References rocksdb::Constructor::Add(), ASSERT_GT, rocksdb::Options::block_restart_interval, BytewiseComparator(), rocksdb::Options::compression, rocksdb::Constructor::Finish(), rocksdb::TableReader::GetTableProperties(), rocksdb::TableProperties::index_size, kNoCompression, rocksdb::test::RandomSeed(), RandomString(), and rocksdb::BlockBasedTableConstructor::table_reader().

                               {
  uint64_t last_index_size = 0;

  // we need to use random keys since the pure human readable texts
  // may be well compressed, resulting insignifcant change of index
  // block size.
  Random rnd(test::RandomSeed());
  std::vector<std::string> keys;

  for (int i = 0; i < 100; ++i) {
    keys.push_back(RandomString(&rnd, 10000));
  }

  // Each time we load one more key to the table. the table index block
  // size is expected to be larger than last time's.
  for (size_t i = 1; i < keys.size(); ++i) {
    BlockBasedTableConstructor c(BytewiseComparator());
    for (size_t j = 0; j < i; ++j) {
      c.Add(keys[j], "val");
    }

    std::vector<std::string> ks;
    KVMap kvmap;
    Options options;
    options.compression = kNoCompression;
    options.block_restart_interval = 1;

    c.Finish(options, &ks, &kvmap);
    auto index_size =
      c.table_reader()->GetTableProperties().index_size;
    ASSERT_GT(index_size, last_index_size);
    last_index_size = index_size;
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		GetOrderedByLevels
	)

Definition at line 883 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                 {
  do {
    ASSERT_OK(Put("foo", "v1"));
    Compact("a", "z");
    ASSERT_EQ("v1", Get("foo"));
    ASSERT_OK(Put("foo", "v2"));
    ASSERT_EQ("v2", Get("foo"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("v2", Get("foo"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	DBTest	,
		GetPicksCorrectFile
	)

Definition at line 895 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                  {
  do {
    // Arrange to have multiple files in a non-level-0 level.
    ASSERT_OK(Put("a", "va"));
    Compact("a", "b");
    ASSERT_OK(Put("x", "vx"));
    Compact("x", "y");
    ASSERT_OK(Put("f", "vf"));
    Compact("f", "g");
    ASSERT_EQ("va", Get("a"));
    ASSERT_EQ("vf", Get("f"));
    ASSERT_EQ("vx", Get("x"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	TableTest	,
		NumBlockStat
	)

Definition at line 908 of file table_test.cc.

References rocksdb::Constructor::Add(), ASSERT_EQ, rocksdb::Options::block_restart_interval, rocksdb::Options::block_size, BytewiseComparator(), rocksdb::Options::compression, rocksdb::Constructor::Finish(), rocksdb::TableReader::GetTableProperties(), kNoCompression, rocksdb::TableProperties::num_data_blocks, rocksdb::test::RandomSeed(), RandomString(), and rocksdb::BlockBasedTableConstructor::table_reader().

                              {
  Random rnd(test::RandomSeed());
  BlockBasedTableConstructor c(BytewiseComparator());
  Options options;
  options.compression = kNoCompression;
  options.block_restart_interval = 1;
  options.block_size = 1000;

  for (int i = 0; i < 10; ++i) {
    // the key/val are slightly smaller than block size, so that each block
    // holds roughly one key/value pair.
    c.Add(RandomString(&rnd, 900), "val");
  }

  std::vector<std::string> ks;
  KVMap kvmap;
  c.Finish(options, &ks, &kvmap);
  ASSERT_EQ(
      kvmap.size(),
      c.table_reader()->GetTableProperties().num_data_blocks
  );
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		GetEncountersEmptyLevel
	)

Definition at line 910 of file db_test.cc.

References ASSERT_EQ, ASSERT_LE, env_, and rocksdb::Env::SleepForMicroseconds().

                                      {
  do {
    // Arrange for the following to happen:
    //   * sstable A in level 0
    //   * nothing in level 1
    //   * sstable B in level 2
    // Then do enough Get() calls to arrange for an automatic compaction
    // of sstable A.  A bug would cause the compaction to be marked as
    // occuring at level 1 (instead of the correct level 0).

    // Step 1: First place sstables in levels 0 and 2
    int compaction_count = 0;
    while (NumTableFilesAtLevel(0) == 0 ||
           NumTableFilesAtLevel(2) == 0) {
      ASSERT_LE(compaction_count, 100) << "could not fill levels 0 and 2";
      compaction_count++;
      Put("a", "begin");
      Put("z", "end");
      dbfull()->TEST_FlushMemTable();
    }

    // Step 2: clear level 1 if necessary.
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
    ASSERT_EQ(NumTableFilesAtLevel(0), 1);
    ASSERT_EQ(NumTableFilesAtLevel(1), 0);
    ASSERT_EQ(NumTableFilesAtLevel(2), 1);

    // Step 3: read a bunch of times
    for (int i = 0; i < 1000; i++) {
      ASSERT_EQ("NOT_FOUND", Get("missing"));
    }

    // Step 4: Wait for compaction to finish
    env_->SleepForMicroseconds(1000000);

    ASSERT_EQ(NumTableFilesAtLevel(0), 1); // XXX
  } while (ChangeOptions(kSkipUniversalCompaction));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		KeyMayExist
	)

Definition at line 952 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, BLOCK_CACHE_ADD, CreateDBStatistics(), db_, rocksdb::DBImpl::Delete(), rocksdb::Options::filter_policy, rocksdb::DBImpl::KeyMayExist(), NewBloomFilterPolicy(), NO_FILE_OPENS, rocksdb::DBImpl::Put(), rocksdb::Options::statistics, value, and value_found.

                          {
  do {
    ReadOptions ropts;
    std::string value;
    Options options = CurrentOptions();
    options.filter_policy = NewBloomFilterPolicy(20);
    options.statistics = rocksdb::CreateDBStatistics();
    Reopen(&options);

    ASSERT_TRUE(!db_->KeyMayExist(ropts, "a", &value));

    ASSERT_OK(db_->Put(WriteOptions(), "a", "b"));
    bool value_found = false;
    ASSERT_TRUE(db_->KeyMayExist(ropts, "a", &value, &value_found));
    ASSERT_TRUE(value_found);
    ASSERT_EQ("b", value);

    dbfull()->Flush(FlushOptions());
    value.clear();

    long numopen = options.statistics.get()->getTickerCount(NO_FILE_OPENS);
    long cache_added =
      options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD);
    ASSERT_TRUE(db_->KeyMayExist(ropts, "a", &value, &value_found));
    ASSERT_TRUE(!value_found);
    // assert that no new files were opened and no new blocks were
    // read into block cache.
    ASSERT_EQ(numopen, options.statistics.get()->getTickerCount(NO_FILE_OPENS));
    ASSERT_EQ(cache_added,
              options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));

    ASSERT_OK(db_->Delete(WriteOptions(), "a"));

    numopen = options.statistics.get()->getTickerCount(NO_FILE_OPENS);
    cache_added =
      options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD);
    ASSERT_TRUE(!db_->KeyMayExist(ropts, "a", &value));
    ASSERT_EQ(numopen, options.statistics.get()->getTickerCount(NO_FILE_OPENS));
    ASSERT_EQ(cache_added,
              options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));

    dbfull()->Flush(FlushOptions());
    dbfull()->CompactRange(nullptr, nullptr);

    numopen = options.statistics.get()->getTickerCount(NO_FILE_OPENS);
    cache_added =
      options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD);
    ASSERT_TRUE(!db_->KeyMayExist(ropts, "a", &value));
    ASSERT_EQ(numopen, options.statistics.get()->getTickerCount(NO_FILE_OPENS));
    ASSERT_EQ(cache_added,
              options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));

    ASSERT_OK(db_->Delete(WriteOptions(), "c"));

    numopen = options.statistics.get()->getTickerCount(NO_FILE_OPENS);
    cache_added =
      options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD);
    ASSERT_TRUE(!db_->KeyMayExist(ropts, "c", &value));
    ASSERT_EQ(numopen, options.statistics.get()->getTickerCount(NO_FILE_OPENS));
    ASSERT_EQ(cache_added,
              options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));

    delete options.filter_policy;
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	TableTest	,
		BlockCacheTest
	)

Definition at line 977 of file table_test.cc.

References rocksdb::Constructor::Add(), ASSERT_EQ, rocksdb::BlockCacheProperties::AssertEqual(), rocksdb::Options::block_cache, BytewiseComparator(), rocksdb::Options::create_if_missing, CreateDBStatistics(), rocksdb::Constructor::Finish(), rocksdb::Iterator::key(), rocksdb::BlockBasedTableConstructor::NewIterator(), NewLRUCache(), rocksdb::BlockBasedTableConstructor::Reopen(), rocksdb::Iterator::SeekToFirst(), rocksdb::Options::statistics, and rocksdb::Slice::ToString().

                                {
  // -- Table construction
  Options options;
  options.create_if_missing = true;
  options.statistics = CreateDBStatistics();
  options.block_cache = NewLRUCache(1024);
  std::vector<std::string> keys;
  KVMap kvmap;

  BlockBasedTableConstructor c(BytewiseComparator());
  c.Add("key", "value");
  c.Finish(options, &keys, &kvmap);

  // -- PART 1: Open with regular block cache.
  // Since block_cache is disabled, no cache activities will be involved.
  unique_ptr<Iterator> iter;

  // At first, no block will be accessed.
  {
    BlockCacheProperties props(options.statistics);
    // index will be added to block cache.
    props.AssertEqual(
        1,  // index block miss
        0,
        0,
        0
    );
  }

  // Only index block will be accessed
  {
    iter.reset(c.NewIterator());
    BlockCacheProperties props(options.statistics);
    // NOTE: to help better highlight the "detla" of each ticker, I use
    // <last_value> + <added_value> to indicate the increment of changed
    // value; other numbers remain the same.
    props.AssertEqual(
        1,
        0 + 1,  // index block hit
        0,
        0
    );
  }

  // Only data block will be accessed
  {
    iter->SeekToFirst();
    BlockCacheProperties props(options.statistics);
    props.AssertEqual(
        1,
        1,
        0 + 1,  // data block miss
        0
    );
  }

  // Data block will be in cache
  {
    iter.reset(c.NewIterator());
    iter->SeekToFirst();
    BlockCacheProperties props(options.statistics);
    props.AssertEqual(
        1,
        1 + 1,  // index block hit
        1,
        0 + 1  // data block hit
    );
  }
  // release the iterator so that the block cache can reset correctly.
  iter.reset();

  // -- PART 2: Open without block cache
  options.block_cache.reset();
  options.statistics = CreateDBStatistics();  // reset the props
  c.Reopen(options);

  {
    iter.reset(c.NewIterator());
    iter->SeekToFirst();
    ASSERT_EQ("key", iter->key().ToString());
    BlockCacheProperties props(options.statistics);
    // Nothing is affected at all
    props.AssertEqual(0, 0, 0, 0);
  }

  // -- PART 3: Open with very small block cache
  // In this test, no block will ever get hit since the block cache is
  // too small to fit even one entry.
  options.block_cache = NewLRUCache(1);
  c.Reopen(options);
  {
    BlockCacheProperties props(options.statistics);
    props.AssertEqual(
        1,  // index block miss
        0,
        0,
        0
    );
  }


  {
    // Both index and data block get accessed.
    // It first cache index block then data block. But since the cache size
    // is only 1, index block will be purged after data block is inserted.
    iter.reset(c.NewIterator());
    BlockCacheProperties props(options.statistics);
    props.AssertEqual(
        1 + 1,  // index block miss
        0,
        0,  // data block miss
        0
    );
  }

  {
    // SeekToFirst() accesses data block. With similar reason, we expect data
    // block's cache miss.
    iter->SeekToFirst();
    BlockCacheProperties props(options.statistics);
    props.AssertEqual(
        2,
        0,
        0 + 1,  // data block miss
        0
    );
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		NonBlockingIteration
	)

Definition at line 1018 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, BLOCK_CACHE_ADD, CreateDBStatistics(), db_, kBlockCacheTier, rocksdb::DBImpl::NewIterator(), NO_FILE_OPENS, rocksdb::DBImpl::Put(), rocksdb::ReadOptions::read_tier, and rocksdb::Options::statistics.

                                   {
  do {
    ReadOptions non_blocking_opts, regular_opts;
    Options options = CurrentOptions();
    options.statistics = rocksdb::CreateDBStatistics();
    non_blocking_opts.read_tier = kBlockCacheTier;
    Reopen(&options);
    // write one kv to the database.
    ASSERT_OK(db_->Put(WriteOptions(), "a", "b"));

    // scan using non-blocking iterator. We should find it because
    // it is in memtable.
    Iterator* iter = db_->NewIterator(non_blocking_opts);
    int count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      count++;
    }
    ASSERT_EQ(count, 1);
    delete iter;

    // flush memtable to storage. Now, the key should not be in the
    // memtable neither in the block cache.
    dbfull()->Flush(FlushOptions());

    // verify that a non-blocking iterator does not find any
    // kvs. Neither does it do any IOs to storage.
    long numopen = options.statistics.get()->getTickerCount(NO_FILE_OPENS);
    long cache_added =
      options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD);
    iter = db_->NewIterator(non_blocking_opts);
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      count++;
    }
    ASSERT_EQ(count, 0);
    ASSERT_TRUE(iter->status().IsIncomplete());
    ASSERT_EQ(numopen, options.statistics.get()->getTickerCount(NO_FILE_OPENS));
    ASSERT_EQ(cache_added,
              options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));
    delete iter;

    // read in the specified block via a regular get
    ASSERT_EQ(Get("a"), "b");

    // verify that we can find it via a non-blocking scan
    numopen = options.statistics.get()->getTickerCount(NO_FILE_OPENS);
    cache_added =
      options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD);
    iter = db_->NewIterator(non_blocking_opts);
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      count++;
    }
    ASSERT_EQ(count, 1);
    ASSERT_EQ(numopen, options.statistics.get()->getTickerCount(NO_FILE_OPENS));
    ASSERT_EQ(cache_added,
              options.statistics.get()->getTickerCount(BLOCK_CACHE_ADD));
    delete iter;

  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		FilterDeletes
	)

Definition at line 1084 of file db_test.cc.

References ASSERT_EQ, rocksdb::WriteBatch::Clear(), rocksdb::WriteBatch::Delete(), rocksdb::Options::filter_deletes, rocksdb::Options::filter_policy, NewBloomFilterPolicy(), and rocksdb::WriteBatch::Put().

                            {
  do {
    Options options = CurrentOptions();
    options.filter_policy = NewBloomFilterPolicy(20);
    options.filter_deletes = true;
    Reopen(&options);
    WriteBatch batch;

    batch.Delete("a");
    dbfull()->Write(WriteOptions(), &batch);
    ASSERT_EQ(AllEntriesFor("a"), "[ ]"); // Delete skipped
    batch.Clear();

    batch.Put("a", "b");
    batch.Delete("a");
    dbfull()->Write(WriteOptions(), &batch);
    ASSERT_EQ(Get("a"), "NOT_FOUND");
    ASSERT_EQ(AllEntriesFor("a"), "[ DEL, b ]"); // Delete issued
    batch.Clear();

    batch.Delete("c");
    batch.Put("c", "d");
    dbfull()->Write(WriteOptions(), &batch);
    ASSERT_EQ(Get("c"), "d");
    ASSERT_EQ(AllEntriesFor("c"), "[ d ]"); // Delete skipped
    batch.Clear();

    dbfull()->Flush(FlushOptions()); // A stray Flush

    batch.Delete("c");
    dbfull()->Write(WriteOptions(), &batch);
    ASSERT_EQ(AllEntriesFor("c"), "[ DEL, d ]"); // Delete issued
    batch.Clear();

    delete options.filter_policy;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	TableTest	,
		ApproximateOffsetOfPlain
	)

Definition at line 1106 of file table_test.cc.

References rocksdb::Constructor::Add(), rocksdb::BlockBasedTableConstructor::ApproximateOffsetOf(), ASSERT_TRUE, Between(), rocksdb::Options::block_size, BytewiseComparator(), rocksdb::Options::compression, rocksdb::Constructor::Finish(), and kNoCompression.

                                          {
  BlockBasedTableConstructor c(BytewiseComparator());
  c.Add("k01", "hello");
  c.Add("k02", "hello2");
  c.Add("k03", std::string(10000, 'x'));
  c.Add("k04", std::string(200000, 'x'));
  c.Add("k05", std::string(300000, 'x'));
  c.Add("k06", "hello3");
  c.Add("k07", std::string(100000, 'x'));
  std::vector<std::string> keys;
  KVMap kvmap;
  Options options;
  options.block_size = 1024;
  options.compression = kNoCompression;
  c.Finish(options, &keys, &kvmap);

  ASSERT_TRUE(Between(c.ApproximateOffsetOf("abc"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01a"),      0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k02"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k03"),       0,      0));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04"),   10000,  11000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04a"), 210000, 211000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k05"),  210000, 211000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k06"),  510000, 511000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("k07"),  510000, 511000));
  ASSERT_TRUE(Between(c.ApproximateOffsetOf("xyz"),  610000, 612000));

}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterEmpty
	)

Definition at line 1122 of file db_test.cc.

References ASSERT_EQ, db_, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Seek(), rocksdb::Iterator::SeekToFirst(), and rocksdb::Iterator::SeekToLast().

                        {
  do {
    Iterator* iter = db_->NewIterator(ReadOptions());

    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("foo");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterSingle
	)

Definition at line 1139 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Iterator::Prev(), rocksdb::Iterator::Seek(), rocksdb::Iterator::SeekToFirst(), and rocksdb::Iterator::SeekToLast().

                         {
  do {
    ASSERT_OK(Put("a", "va"));
    Iterator* iter = db_->NewIterator(ReadOptions());

    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("a");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("b");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	TableTest	,
		ApproximateOffsetOfCompressed
	)

Definition at line 1159 of file table_test.cc.

References Do_Compression_Test(), kSnappyCompression, kZlibCompression, SnappyCompressionSupported(), and ZlibCompressionSupported().

                                               {
  CompressionType compression_state[2];
  int valid = 0;
  if (!SnappyCompressionSupported()) {
    fprintf(stderr, "skipping snappy compression tests\n");
  } else {
    compression_state[valid] = kSnappyCompression;
    valid++;
  }

  if (!ZlibCompressionSupported()) {
    fprintf(stderr, "skipping zlib compression tests\n");
  } else {
    compression_state[valid] = kZlibCompression;
    valid++;
  }

  for(int i =0; i < valid; i++)
  {
    Do_Compression_Test(compression_state[i]);
  }

}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterMulti
	)

Definition at line 1179 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Iterator::Prev(), rocksdb::Iterator::Seek(), rocksdb::Iterator::SeekToFirst(), and rocksdb::Iterator::SeekToLast().

                        {
  do {
    ASSERT_OK(Put("a", "va"));
    ASSERT_OK(Put("b", "vb"));
    ASSERT_OK(Put("c", "vc"));
    Iterator* iter = db_->NewIterator(ReadOptions());

    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Seek("a");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Seek("ax");
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Seek("b");
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Seek("z");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    // Switch from reverse to forward
    iter->SeekToLast();
    iter->Prev();
    iter->Prev();
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");

    // Switch from forward to reverse
    iter->SeekToFirst();
    iter->Next();
    iter->Next();
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");

    // Make sure iter stays at snapshot
    ASSERT_OK(Put("a",  "va2"));
    ASSERT_OK(Put("a2", "va3"));
    ASSERT_OK(Put("b",  "vb2"));
    ASSERT_OK(Put("c",  "vc2"));
    ASSERT_OK(Delete("b"));
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	TableTest	,
		BlockCacheLeak
	)

Definition at line 1183 of file table_test.cc.

References rocksdb::Constructor::Add(), ASSERT_OK, ASSERT_TRUE, rocksdb::Options::block_cache, rocksdb::Options::block_size, BytewiseComparator(), rocksdb::Options::compression, rocksdb::Constructor::Finish(), kNoCompression, rocksdb::BlockBasedTableConstructor::NewIterator(), NewLRUCache(), rocksdb::BlockBasedTableConstructor::Reopen(), rocksdb::BlockBasedTableConstructor::table_reader(), and rocksdb::TableReader::TEST_KeyInCache().

                                {
  // Check that when we reopen a table we don't lose access to blocks already
  // in the cache. This test checks whether the Table actually makes use of the
  // unique ID from the file.

  Options opt;
  opt.block_size = 1024;
  opt.compression = kNoCompression;
  opt.block_cache = NewLRUCache(16*1024*1024); // big enough so we don't ever
                                               // lose cached values.

  BlockBasedTableConstructor c(BytewiseComparator());
  c.Add("k01", "hello");
  c.Add("k02", "hello2");
  c.Add("k03", std::string(10000, 'x'));
  c.Add("k04", std::string(200000, 'x'));
  c.Add("k05", std::string(300000, 'x'));
  c.Add("k06", "hello3");
  c.Add("k07", std::string(100000, 'x'));
  std::vector<std::string> keys;
  KVMap kvmap;
  c.Finish(opt, &keys, &kvmap);

  unique_ptr<Iterator> iter(c.NewIterator());
  iter->SeekToFirst();
  while (iter->Valid()) {
    iter->key();
    iter->value();
    iter->Next();
  }
  ASSERT_OK(iter->status());

  ASSERT_OK(c.Reopen(opt));
  for (const std::string& key: keys) {
    ASSERT_TRUE(c.table_reader()->TEST_KeyInCache(ReadOptions(), key));
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	Harness	,
		Randomized
	)

Definition at line 1221 of file table_test.cc.

References GenerateArgList(), rocksdb::test::RandomKey(), rocksdb::test::RandomSeed(), rocksdb::test::RandomString(), and rocksdb::Random::Skewed().

                          {
  std::vector<TestArgs> args = GenerateArgList();
  for (unsigned int i = 0; i < args.size(); i++) {
    Init(args[i]);
    Random rnd(test::RandomSeed() + 5);
    for (int num_entries = 0; num_entries < 2000;
         num_entries += (num_entries < 50 ? 1 : 200)) {
      if ((num_entries % 10) == 0) {
        fprintf(stderr, "case %d of %d: num_entries = %d\n",
                (i + 1), int(args.size()), num_entries);
      }
      for (int e = 0; e < num_entries; e++) {
        std::string v;
        Add(test::RandomKey(&rnd, rnd.Skewed(4)),
            test::RandomString(&rnd, rnd.Skewed(5), &v).ToString());
      }
      Test(&rnd);
    }
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	Harness	,
		RandomizedLongDB
	)

Definition at line 1242 of file table_test.cc.

References ASSERT_GT, ASSERT_TRUE, db, DB_TEST, kNoCompression, name, rocksdb::DBImpl::NumberLevels(), rocksdb::test::RandomKey(), rocksdb::test::RandomSeed(), rocksdb::test::RandomString(), rocksdb::Random::Skewed(), and value.

                                {
  Random rnd(test::RandomSeed());
  TestArgs args = { DB_TEST, false, 16, kNoCompression };
  Init(args);
  int num_entries = 100000;
  for (int e = 0; e < num_entries; e++) {
    std::string v;
    Add(test::RandomKey(&rnd, rnd.Skewed(4)),
        test::RandomString(&rnd, rnd.Skewed(5), &v).ToString());
  }
  Test(&rnd);

  // We must have created enough data to force merging
  int files = 0;
  for (int level = 0; level < db()->NumberLevels(); level++) {
    std::string value;
    char name[100];
    snprintf(name, sizeof(name), "rocksdb.num-files-at-level%d", level);
    ASSERT_TRUE(db()->GetProperty(name, &value));
    files += atoi(value.c_str());
  }
  ASSERT_GT(files, 0);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterReseek
	)

Definition at line 1266 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::create_if_missing, CreateDBStatistics(), db_, rocksdb::Options::max_sequential_skip_in_iterations, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), NUMBER_OF_RESEEKS_IN_ITERATION, rocksdb::Iterator::Prev(), rocksdb::Iterator::SeekToFirst(), rocksdb::Iterator::SeekToLast(), and rocksdb::Options::statistics.

                         {
  Options options = CurrentOptions();
  options.max_sequential_skip_in_iterations = 3;
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  DestroyAndReopen(&options);

  // insert two keys with same userkey and verify that
  // reseek is not invoked. For each of these test cases,
  // verify that we can find the next key "b".
  ASSERT_OK(Put("a",  "one"));
  ASSERT_OK(Put("a",  "two"));
  ASSERT_OK(Put("b",  "bone"));
  Iterator* iter = db_->NewIterator(ReadOptions());
  iter->SeekToFirst();
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), 0);
  ASSERT_EQ(IterStatus(iter), "a->two");
  iter->Next();
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), 0);
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // insert a total of three keys with same userkey and verify
  // that reseek is still not invoked.
  ASSERT_OK(Put("a",  "three"));
  iter = db_->NewIterator(ReadOptions());
  iter->SeekToFirst();
  ASSERT_EQ(IterStatus(iter), "a->three");
  iter->Next();
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), 0);
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // insert a total of four keys with same userkey and verify
  // that reseek is invoked.
  ASSERT_OK(Put("a",  "four"));
  iter = db_->NewIterator(ReadOptions());
  iter->SeekToFirst();
  ASSERT_EQ(IterStatus(iter), "a->four");
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), 0);
  iter->Next();
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), 1);
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // Testing reverse iterator
  // At this point, we have three versions of "a" and one version of "b".
  // The reseek statistics is already at 1.
  int num_reseeks = (int)options.statistics.get()->getTickerCount(
                 NUMBER_OF_RESEEKS_IN_ITERATION);

  // Insert another version of b and assert that reseek is not invoked
  ASSERT_OK(Put("b",  "btwo"));
  iter = db_->NewIterator(ReadOptions());
  iter->SeekToLast();
  ASSERT_EQ(IterStatus(iter), "b->btwo");
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), num_reseeks);
  iter->Prev();
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), num_reseeks+1);
  ASSERT_EQ(IterStatus(iter), "a->four");
  delete iter;

  // insert two more versions of b. This makes a total of 4 versions
  // of b and 4 versions of a.
  ASSERT_OK(Put("b",  "bthree"));
  ASSERT_OK(Put("b",  "bfour"));
  iter = db_->NewIterator(ReadOptions());
  iter->SeekToLast();
  ASSERT_EQ(IterStatus(iter), "b->bfour");
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), num_reseeks + 2);
  iter->Prev();

  // the previous Prev call should have invoked reseek
  ASSERT_EQ(options.statistics.get()->getTickerCount(
            NUMBER_OF_RESEEKS_IN_ITERATION), num_reseeks + 3);
  ASSERT_EQ(IterStatus(iter), "a->four");
  delete iter;
}

Here is the call graph for this function:

rocksdb::TEST	(	MemTableTest	,
		Simple
	)

Definition at line 1268 of file table_test.cc.

References ASSERT_TRUE, BytewiseComparator(), rocksdb::WriteBatchInternal::InsertInto(), rocksdb::Iterator::key(), rocksdb::Iterator::Next(), ripple::Resource::ok, rocksdb::WriteBatch::Put(), rocksdb::Iterator::SeekToFirst(), rocksdb::WriteBatchInternal::SetSequence(), rocksdb::Slice::ToString(), rocksdb::Iterator::Valid(), and rocksdb::Iterator::value().

                           {
  InternalKeyComparator cmp(BytewiseComparator());
  auto table_factory = std::make_shared<SkipListFactory>();
  MemTable* memtable = new MemTable(cmp, table_factory);
  memtable->Ref();
  WriteBatch batch;
  Options options;
  WriteBatchInternal::SetSequence(&batch, 100);
  batch.Put(std::string("k1"), std::string("v1"));
  batch.Put(std::string("k2"), std::string("v2"));
  batch.Put(std::string("k3"), std::string("v3"));
  batch.Put(std::string("largekey"), std::string("vlarge"));
  ASSERT_TRUE(WriteBatchInternal::InsertInto(&batch, memtable, &options).ok());

  Iterator* iter = memtable->NewIterator();
  iter->SeekToFirst();
  while (iter->Valid()) {
    fprintf(stderr, "key: '%s' -> '%s'\n",
            iter->key().ToString().c_str(),
            iter->value().ToString().c_str());
    iter->Next();
  }

  delete iter;
  memtable->Unref();
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterSmallAndLargeMix
	)

Definition at line 1353 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Iterator::Prev(), rocksdb::Iterator::SeekToFirst(), and rocksdb::Iterator::SeekToLast().

                                   {
  do {
    ASSERT_OK(Put("a", "va"));
    ASSERT_OK(Put("b", std::string(100000, 'b')));
    ASSERT_OK(Put("c", "vc"));
    ASSERT_OK(Put("d", std::string(100000, 'd')));
    ASSERT_OK(Put("e", std::string(100000, 'e')));

    Iterator* iter = db_->NewIterator(ReadOptions());

    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterMultiWithDelete
	)

Definition at line 1393 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, merge_operator, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Prev(), and rocksdb::Iterator::Seek().

                                  {
  do {
    ASSERT_OK(Put("a", "va"));
    ASSERT_OK(Put("b", "vb"));
    ASSERT_OK(Put("c", "vc"));
    ASSERT_OK(Delete("b"));
    ASSERT_EQ("NOT_FOUND", Get("b"));

    Iterator* iter = db_->NewIterator(ReadOptions());
    iter->Seek("c");
    ASSERT_EQ(IterStatus(iter), "c->vc");
    if (!CurrentOptions().merge_operator) {
      // TODO: merge operator does not support backward iteration yet
      iter->Prev();
      ASSERT_EQ(IterStatus(iter), "a->va");
    }
    delete iter;
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterPrevMaxSkip
	)

Definition at line 1413 of file db_test.cc.

References ASSERT_OK, db_, rocksdb::DBImpl::Delete(), and rocksdb::DBImpl::Put().

                              {
  do {
    for (int i = 0; i < 2; i++) {
      db_->Put(WriteOptions(), "key1", "v1");
      db_->Put(WriteOptions(), "key2", "v2");
      db_->Put(WriteOptions(), "key3", "v3");
      db_->Put(WriteOptions(), "key4", "v4");
      db_->Put(WriteOptions(), "key5", "v5");
    }

    VerifyIterLast("key5->v5");

    ASSERT_OK(db_->Delete(WriteOptions(), "key5"));
    VerifyIterLast("key4->v4");

    ASSERT_OK(db_->Delete(WriteOptions(), "key4"));
    VerifyIterLast("key3->v3");

    ASSERT_OK(db_->Delete(WriteOptions(), "key3"));
    VerifyIterLast("key2->v2");

    ASSERT_OK(db_->Delete(WriteOptions(), "key2"));
    VerifyIterLast("key1->v1");

    ASSERT_OK(db_->Delete(WriteOptions(), "key1"));
    VerifyIterLast("(invalid)");
  } while (ChangeOptions(kSkipMergePut));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IterWithSnapshot
	)

Definition at line 1442 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db_, rocksdb::DBImpl::GetSnapshot(), merge_operator, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Iterator::Prev(), rocksdb::DBImpl::ReleaseSnapshot(), rocksdb::Iterator::Seek(), rocksdb::ReadOptions::snapshot, and rocksdb::Iterator::Valid().

                               {
  do {
    ASSERT_OK(Put("key1", "val1"));
    ASSERT_OK(Put("key2", "val2"));
    ASSERT_OK(Put("key3", "val3"));
    ASSERT_OK(Put("key4", "val4"));
    ASSERT_OK(Put("key5", "val5"));

    const Snapshot *snapshot = db_->GetSnapshot();
    ReadOptions options;
    options.snapshot = snapshot;
    Iterator* iter = db_->NewIterator(options);

    // Put more values after the snapshot
    ASSERT_OK(Put("key100", "val100"));
    ASSERT_OK(Put("key101", "val101"));

    iter->Seek("key5");
    ASSERT_EQ(IterStatus(iter), "key5->val5");
    if (!CurrentOptions().merge_operator) {
      // TODO: merge operator does not support backward iteration yet
      iter->Prev();
      ASSERT_EQ(IterStatus(iter), "key4->val4");
      iter->Prev();
      ASSERT_EQ(IterStatus(iter), "key3->val3");

      iter->Next();
      ASSERT_EQ(IterStatus(iter), "key4->val4");
      iter->Next();
      ASSERT_EQ(IterStatus(iter), "key5->val5");
      iter->Next();
      ASSERT_TRUE(!iter->Valid());
    }
    db_->ReleaseSnapshot(snapshot);
    delete iter;
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		Recover
	)

Definition at line 1480 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                      {
  do {
    ASSERT_OK(Put("foo", "v1"));
    ASSERT_OK(Put("baz", "v5"));

    Reopen();
    ASSERT_EQ("v1", Get("foo"));

    ASSERT_EQ("v1", Get("foo"));
    ASSERT_EQ("v5", Get("baz"));
    ASSERT_OK(Put("bar", "v2"));
    ASSERT_OK(Put("foo", "v3"));

    Reopen();
    ASSERT_EQ("v3", Get("foo"));
    ASSERT_OK(Put("foo", "v4"));
    ASSERT_EQ("v4", Get("foo"));
    ASSERT_EQ("v2", Get("bar"));
    ASSERT_EQ("v5", Get("baz"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	DBTest	,
		RollLog
	)

Definition at line 1502 of file db_test.cc.

References ASSERT_OK.

                      {
  do {
    ASSERT_OK(Put("foo", "v1"));
    ASSERT_OK(Put("baz", "v5"));

    Reopen();
    for (int i = 0; i < 10; i++) {
      Reopen();
    }
    ASSERT_OK(Put("foo", "v4"));
    for (int i = 0; i < 10; i++) {
      Reopen();
    }
  } while (ChangeOptions());
}

rocksdb::TEST	(	DBTest	,
		WAL
	)

Definition at line 1518 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, and rocksdb::WriteOptions::disableWAL.

                  {
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v1"));
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v1"));

    Reopen();
    ASSERT_EQ("v1", Get("foo"));
    ASSERT_EQ("v1", Get("bar"));

    writeOpt.disableWAL = false;
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v2"));
    writeOpt.disableWAL = true;
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v2"));

    Reopen();
    // Both value's should be present.
    ASSERT_EQ("v2", Get("bar"));
    ASSERT_EQ("v2", Get("foo"));

    writeOpt.disableWAL = true;
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v3"));
    writeOpt.disableWAL = false;
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v3"));

    Reopen();
    // again both values should be present.
    ASSERT_EQ("v3", Get("foo"));
    ASSERT_EQ("v3", Get("bar"));
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		CheckLock
	)

Definition at line 1552 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, and ripple::Resource::ok.

                        {
  do {
    DB* localdb;
    Options options = CurrentOptions();
    ASSERT_OK(TryReopen(&options));

    // second open should fail
    ASSERT_TRUE(!(PureReopen(&options, &localdb)).ok());
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		FlushMultipleMemtable
	)

Definition at line 1563 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::WriteOptions::disableWAL, rocksdb::Options::max_write_buffer_number, and rocksdb::Options::min_write_buffer_number_to_merge.

                                    {
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
    Reopen(&options);
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v1"));
    dbfull()->Flush(FlushOptions());
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v1"));

    ASSERT_EQ("v1", Get("foo"));
    ASSERT_EQ("v1", Get("bar"));
    dbfull()->Flush(FlushOptions());
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		NumImmutableMemTable
	)

Definition at line 1581 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::WriteOptions::disableWAL, rocksdb::Options::max_write_buffer_number, rocksdb::Options::min_write_buffer_number_to_merge, and rocksdb::Options::write_buffer_size.

                                   {
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
    options.write_buffer_size = 1000000;
    Reopen(&options);

    std::string big_value(1000000, 'x');
    std::string num;

    ASSERT_OK(dbfull()->Put(writeOpt, "k1", big_value));
    ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
    ASSERT_EQ(num, "0");

    ASSERT_OK(dbfull()->Put(writeOpt, "k2", big_value));
    ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
    ASSERT_EQ(num, "1");

    ASSERT_OK(dbfull()->Put(writeOpt, "k3", big_value));
    ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
    ASSERT_EQ(num, "2");

    dbfull()->Flush(FlushOptions());
    ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
    ASSERT_EQ(num, "0");
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		FLUSH
	)

Definition at line 1612 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, and rocksdb::WriteOptions::disableWAL.

                    {
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v1"));
    // this will now also flush the last 2 writes
    dbfull()->Flush(FlushOptions());
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v1"));

    Reopen();
    ASSERT_EQ("v1", Get("foo"));
    ASSERT_EQ("v1", Get("bar"));

    writeOpt.disableWAL = true;
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v2"));
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v2"));
    dbfull()->Flush(FlushOptions());

    Reopen();
    ASSERT_EQ("v2", Get("bar"));
    ASSERT_EQ("v2", Get("foo"));

    writeOpt.disableWAL = false;
    ASSERT_OK(dbfull()->Put(writeOpt, "bar", "v3"));
    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v3"));
    dbfull()->Flush(FlushOptions());

    Reopen();
    // 'foo' should be there because its put
    // has WAL enabled.
    ASSERT_EQ("v3", Get("foo"));
    ASSERT_EQ("v3", Get("bar"));
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		RecoveryWithEmptyLog
	)

Definition at line 1648 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                   {
  do {
    ASSERT_OK(Put("foo", "v1"));
    ASSERT_OK(Put("foo", "v2"));
    Reopen();
    Reopen();
    ASSERT_OK(Put("foo", "v3"));
    Reopen();
    ASSERT_EQ("v3", Get("foo"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	DBTest	,
		RecoverDuringMemtableCompaction
	)

Definition at line 1662 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::env, env_, and rocksdb::Options::write_buffer_size.

                                              {
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.write_buffer_size = 1000000;
    Reopen(&options);

    // Trigger a long memtable compaction and reopen the database during it
    ASSERT_OK(Put("foo", "v1"));                         // Goes to 1st log file
    ASSERT_OK(Put("big1", std::string(10000000, 'x')));  // Fills memtable
    ASSERT_OK(Put("big2", std::string(1000, 'y')));      // Triggers compaction
    ASSERT_OK(Put("bar", "v2"));                         // Goes to new log file

    Reopen(&options);
    ASSERT_EQ("v1", Get("foo"));
    ASSERT_EQ("v2", Get("bar"));
    ASSERT_EQ(std::string(10000000, 'x'), Get("big1"));
    ASSERT_EQ(std::string(1000, 'y'), Get("big2"));
  } while (ChangeOptions());
}

rocksdb::TEST	(	DBTest	,
		MinorCompactionsHappen
	)

Definition at line 1683 of file db_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, and rocksdb::Options::write_buffer_size.

                                     {
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 10000;
    Reopen(&options);

    const int N = 500;

    int starting_num_tables = TotalTableFiles();
    for (int i = 0; i < N; i++) {
      ASSERT_OK(Put(Key(i), Key(i) + std::string(1000, 'v')));
    }
    int ending_num_tables = TotalTableFiles();
    ASSERT_GT(ending_num_tables, starting_num_tables);

    for (int i = 0; i < N; i++) {
      ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(Key(i)));
    }

    Reopen();

    for (int i = 0; i < N; i++) {
      ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(Key(i)));
    }
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		ManifestRollOver
	)

Definition at line 1710 of file db_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, and rocksdb::Options::max_manifest_file_size.

                               {
  do {
    Options options = CurrentOptions();
    options.max_manifest_file_size = 10 ;  // 10 bytes
    Reopen(&options);
    {
      ASSERT_OK(Put("manifest_key1", std::string(1000, '1')));
      ASSERT_OK(Put("manifest_key2", std::string(1000, '2')));
      ASSERT_OK(Put("manifest_key3", std::string(1000, '3')));
      uint64_t manifest_before_flush =
        dbfull()->TEST_Current_Manifest_FileNo();
      dbfull()->Flush(FlushOptions()); // This should trigger LogAndApply.
      uint64_t manifest_after_flush =
        dbfull()->TEST_Current_Manifest_FileNo();
      ASSERT_GT(manifest_after_flush, manifest_before_flush);
      Reopen(&options);
      ASSERT_GT(dbfull()->TEST_Current_Manifest_FileNo(),
                manifest_after_flush);
      // check if a new manifest file got inserted or not.
      ASSERT_EQ(std::string(1000, '1'), Get("manifest_key1"));
      ASSERT_EQ(std::string(1000, '2'), Get("manifest_key2"));
      ASSERT_EQ(std::string(1000, '3'), Get("manifest_key3"));
    }
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		IdentityAcrossRestarts
	)

Definition at line 1736 of file db_test.cc.

References ASSERT_EQ, ASSERT_NE, ASSERT_OK, dbname_, rocksdb::Env::DeleteFile(), env_, IdentityFileName(), rocksdb::Env::NewSequentialFile(), rocksdb::SequentialFile::Read(), and rocksdb::Slice::ToString().

                                     {
  do {
    std::string idfilename = IdentityFileName(dbname_);
    unique_ptr<SequentialFile> idfile;
    const EnvOptions soptions;
    ASSERT_OK(env_->NewSequentialFile(idfilename, &idfile, soptions));
    char buffer1[100];
    Slice id1;
    ASSERT_OK(idfile->Read(100, &id1, buffer1));

    Options options = CurrentOptions();
    Reopen(&options);
    char buffer2[100];
    Slice id2;
    ASSERT_OK(env_->NewSequentialFile(idfilename, &idfile, soptions));
    ASSERT_OK(idfile->Read(100, &id2, buffer2));
    // id1 should match id2 because identity was not regenerated
    ASSERT_EQ(id1.ToString(), id2.ToString());

    ASSERT_OK(env_->DeleteFile(idfilename));
    Reopen(&options);
    char buffer3[100];
    Slice id3;
    ASSERT_OK(env_->NewSequentialFile(idfilename, &idfile, soptions));
    ASSERT_OK(idfile->Read(100, &id3, buffer3));
    // id1 should NOT match id2 because identity was regenerated
    ASSERT_NE(id1.ToString(0), id3.ToString());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		RecoverWithLargeLog
	)

Definition at line 1766 of file db_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, and rocksdb::Options::write_buffer_size.

                                  {
  do {
    {
      Options options = CurrentOptions();
      Reopen(&options);
      ASSERT_OK(Put("big1", std::string(200000, '1')));
      ASSERT_OK(Put("big2", std::string(200000, '2')));
      ASSERT_OK(Put("small3", std::string(10, '3')));
      ASSERT_OK(Put("small4", std::string(10, '4')));
      ASSERT_EQ(NumTableFilesAtLevel(0), 0);
    }

    // Make sure that if we re-open with a small write buffer size that
    // we flush table files in the middle of a large log file.
    Options options = CurrentOptions();
    options.write_buffer_size = 100000;
    Reopen(&options);
    ASSERT_EQ(NumTableFilesAtLevel(0), 3);
    ASSERT_EQ(std::string(200000, '1'), Get("big1"));
    ASSERT_EQ(std::string(200000, '2'), Get("big2"));
    ASSERT_EQ(std::string(10, '3'), Get("small3"));
    ASSERT_EQ(std::string(10, '4'), Get("small4"));
    ASSERT_GT(NumTableFilesAtLevel(0), 1);
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		CompactionsGenerateMultipleFiles
	)

Definition at line 1792 of file db_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, RandomString(), and rocksdb::Options::write_buffer_size.

                                               {
  Options options = CurrentOptions();
  options.write_buffer_size = 100000000;        // Large write buffer
  Reopen(&options);

  Random rnd(301);

  // Write 8MB (80 values, each 100K)
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  std::vector<std::string> values;
  for (int i = 0; i < 80; i++) {
    values.push_back(RandomString(&rnd, 100000));
    ASSERT_OK(Put(Key(i), values[i]));
  }

  // Reopening moves updates to level-0
  Reopen(&options);
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);

  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_GT(NumTableFilesAtLevel(1), 1);
  for (int i = 0; i < 80; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		CompactionTrigger
	)

Definition at line 1906 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::level0_file_num_compaction_trigger, rocksdb::Options::max_mem_compaction_level, rocksdb::Options::num_levels, RandomString(), and rocksdb::Options::write_buffer_size.

                                {
  Options options = CurrentOptions();
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
  Reopen(&options);

  Random rnd(301);

  for (int num = 0;
       num < options.level0_file_num_compaction_trigger - 1;
       num++) {
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      values.push_back(RandomString(&rnd, 10000));
      ASSERT_OK(Put(Key(i), values[i]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(NumTableFilesAtLevel(0), num + 1);
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
    values.push_back(RandomString(&rnd, 10000));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		UniversalCompactionTrigger
	)

Definition at line 1941 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::compaction_style, kCompactionStyleUniversal, rocksdb::Options::level0_file_num_compaction_trigger, rocksdb::Options::num_levels, RandomString(), and rocksdb::Options::write_buffer_size.

                                         {
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100<<10; //100KB
  // trigger compaction if there are >= 4 files
  options.level0_file_num_compaction_trigger = 4;
  Reopen(&options);

  Random rnd(301);
  int key_idx = 0;

  // Stage 1:
  //   Generate a set of files at level 0, but don't trigger level-0
  //   compaction.
  for (int num = 0;
       num < options.level0_file_num_compaction_trigger-1;
       num++) {
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(NumTableFilesAtLevel(0), num + 1);
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
  for (int i = 0; i < 12; i++) {
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Suppose each file flushed from mem table has size 1. Now we compact
  // (level0_file_num_compaction_trigger+1)=4 files and should have a big
  // file of size 4.
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
  for (int i = 1; i < options.num_levels ; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }

  // Stage 2:
  //   Now we have one file at level 0, with size 4. We also have some data in
  //   mem table. Let's continue generating new files at level 0, but don't
  //   trigger level-0 compaction.
  //   First, clean up memtable before inserting new data. This will generate
  //   a level-0 file, with size around 0.4 (according to previously written
  //   data amount).
  dbfull()->Flush(FlushOptions());
  for (int num = 0;
       num < options.level0_file_num_compaction_trigger-3;
       num++) {
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(NumTableFilesAtLevel(0), num + 3);
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
  for (int i = 0; i < 12; i++) {
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Before compaction, we have 4 files at level 0, with size 4, 0.4, 1, 1.
  // After comapction, we should have 2 files, with size 4, 2.4.
  ASSERT_EQ(NumTableFilesAtLevel(0), 2);
  for (int i = 1; i < options.num_levels ; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }

  // Stage 3:
  //   Now we have 2 files at level 0, with size 4 and 2.4. Continue
  //   generating new files at level 0.
  for (int num = 0;
       num < options.level0_file_num_compaction_trigger-3;
       num++) {
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(NumTableFilesAtLevel(0), num + 3);
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
  for (int i = 0; i < 12; i++) {
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Before compaction, we have 4 files at level 0, with size 4, 2.4, 1, 1.
  // After comapction, we should have 3 files, with size 4, 2.4, 2.
  ASSERT_EQ(NumTableFilesAtLevel(0), 3);
  for (int i = 1; i < options.num_levels ; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }

  // Stage 4:
  //   Now we have 3 files at level 0, with size 4, 2.4, 2. Let's generate a
  //   new file of size 1.
  for (int i = 0; i < 12; i++) {
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Level-0 compaction is triggered, but no file will be picked up.
  ASSERT_EQ(NumTableFilesAtLevel(0), 4);
  for (int i = 1; i < options.num_levels ; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }

  // Stage 5:
  //   Now we have 4 files at level 0, with size 4, 2.4, 2, 1. Let's generate
  //   a new file of size 1.
  for (int i = 0; i < 12; i++) {
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // All files at level 0 will be compacted into a single one.
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
  for (int i = 1; i < options.num_levels ; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		UniversalCompactionSizeAmplification
	)

Definition at line 2074 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::compaction_options_universal, rocksdb::Options::compaction_style, kCompactionStyleUniversal, rocksdb::Options::level0_file_num_compaction_trigger, RandomString(), and rocksdb::Options::write_buffer_size.

                                                   {
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100<<10; //100KB
  options.level0_file_num_compaction_trigger = 3;

  // Trigger compaction if size amplification exceeds 110%
  options.compaction_options_universal.
    max_size_amplification_percent = 110;
  Reopen(&options);

  Random rnd(301);
  int key_idx = 0;

  //   Generate two files in Level 0. Both files are approx the same size.
  for (int num = 0;
       num < options.level0_file_num_compaction_trigger-1;
       num++) {
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    ASSERT_EQ(NumTableFilesAtLevel(0), num + 1);
  }
  ASSERT_EQ(NumTableFilesAtLevel(0), 2);

  // Flush whatever is remaining in memtable. This is typically
  // small, which should not trigger size ratio based compaction
  // but will instead trigger size amplification.
  dbfull()->Flush(FlushOptions());

  dbfull()->TEST_WaitForCompact();

  // Verify that size amplification did occur
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		UniversalCompactionOptions
	)

Definition at line 2113 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::compaction_options_universal, rocksdb::Options::compaction_style, rocksdb::CompactionOptionsUniversal::compression_size_percent, kCompactionStyleUniversal, rocksdb::Options::level0_file_num_compaction_trigger, rocksdb::Options::num_levels, RandomString(), and rocksdb::Options::write_buffer_size.

                                         {
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100<<10; //100KB
  options.level0_file_num_compaction_trigger = 4;
  options.num_levels = 1;
  options.compaction_options_universal.compression_size_percent = -1;
  Reopen(&options);

  Random rnd(301);
  int key_idx = 0;

  for (int num = 0;
       num < options.level0_file_num_compaction_trigger;
       num++) {
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();

    if (num < options.level0_file_num_compaction_trigger - 1) {
      ASSERT_EQ(NumTableFilesAtLevel(0), num + 1);
    }
  }

  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
  for (int i = 1; i < options.num_levels ; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ConvertCompactionStyle
	)

Definition at line 2248 of file db_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, ASSERT_TRUE, rocksdb::Options::compaction_style, rocksdb::Status::IsInvalidArgument(), kCompactionStyleUniversal, rocksdb::Iterator::key(), rocksdb::Options::level0_file_num_compaction_trigger, rocksdb::Options::max_bytes_for_level_base, rocksdb::Options::max_bytes_for_level_multiplier, rocksdb::Iterator::Next(), rocksdb::Options::num_levels, RandomString(), rocksdb::Iterator::SeekToFirst(), rocksdb::Options::target_file_size_base, rocksdb::Options::target_file_size_multiplier, rocksdb::Slice::ToString(), rocksdb::Iterator::Valid(), and rocksdb::Options::write_buffer_size.

                                     {
  Random rnd(301);
  int max_key_level_insert = 200;
  int max_key_universal_insert = 600;

  // Stage 1: generate a db with level compaction
  Options options = CurrentOptions();
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 4;
  options.level0_file_num_compaction_trigger = 3;
  options.max_bytes_for_level_base = 500<<10; // 500KB
  options.max_bytes_for_level_multiplier = 1;
  options.target_file_size_base = 200<<10; // 200KB
  options.target_file_size_multiplier = 1;
  Reopen(&options);

  for (int i = 0; i <= max_key_level_insert; i++) {
    // each value is 10K
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 10000)));
  }
  dbfull()->Flush(FlushOptions());
  dbfull()->TEST_WaitForCompact();

  ASSERT_GT(TotalTableFiles(), 1);
  int non_level0_num_files = 0;
  for (int i = 1; i < dbfull()->NumberLevels(); i++) {
    non_level0_num_files += NumTableFilesAtLevel(i);
  }
  ASSERT_GT(non_level0_num_files, 0);

  // Stage 2: reopen with universal compaction - should fail
  options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  Status s = TryReopen(&options);
  ASSERT_TRUE(s.IsInvalidArgument());

  // Stage 3: compact into a single file and move the file to level 0
  options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.target_file_size_base = INT_MAX;
  options.target_file_size_multiplier = 1;
  options.max_bytes_for_level_base = INT_MAX;
  options.max_bytes_for_level_multiplier = 1;
  Reopen(&options);

  dbfull()->CompactRange(nullptr, nullptr,
                         true /* reduce level */,
                         0    /* reduce to level 0 */);

  for (int i = 0; i < dbfull()->NumberLevels(); i++) {
    int num = NumTableFilesAtLevel(i);
    if (i == 0) {
      ASSERT_EQ(num, 1);
    } else {
      ASSERT_EQ(num, 0);
    }
  }

  // Stage 4: re-open in universal compaction style and do some db operations
  options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100<<10; //100KB
  options.level0_file_num_compaction_trigger = 3;
  Reopen(&options);

  for (int i = max_key_level_insert / 2; i <= max_key_universal_insert; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 10000)));
  }
  dbfull()->Flush(FlushOptions());
  dbfull()->TEST_WaitForCompact();

  for (int i = 1; i < dbfull()->NumberLevels(); i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i), 0);
  }

  // verify keys inserted in both level compaction style and universal
  // compaction style
  std::string keys_in_db;
  Iterator* iter = dbfull()->NewIterator(ReadOptions());
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    keys_in_db.append(iter->key().ToString());
    keys_in_db.push_back(',');
  }
  delete iter;

  std::string expected_keys;
  for (int i = 0; i <= max_key_universal_insert; i++) {
    expected_keys.append(Key(i));
    expected_keys.push_back(',');
  }

  ASSERT_EQ(keys_in_db, expected_keys);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		MinLevelToCompress1
	)

Definition at line 2408 of file db_test.cc.

References rocksdb::Options::compression_per_level, kNoCompression, MinLevelHelper(), MinLevelToCompress(), and rocksdb::Options::num_levels.

                                  {
  Options options = CurrentOptions();
  CompressionType type;
  if (!MinLevelToCompress(type, options, -14, -1, 0)) {
    return;
  }
  Reopen(&options);
  MinLevelHelper(this, options);

  // do not compress L0 and L1
  for (int i = 0; i < 2; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 2; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
  DestroyAndReopen(&options);
  MinLevelHelper(this, options);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		MinLevelToCompress2
	)

Definition at line 2428 of file db_test.cc.

References rocksdb::Options::compression_per_level, kNoCompression, MinLevelHelper(), MinLevelToCompress(), and rocksdb::Options::num_levels.

                                  {
  Options options = CurrentOptions();
  CompressionType type;
  if (!MinLevelToCompress(type, options, 15, -1, 0)) {
    return;
  }
  Reopen(&options);
  MinLevelHelper(this, options);

  // do not compress L0 and L1
  for (int i = 0; i < 2; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 2; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
  DestroyAndReopen(&options);
  MinLevelHelper(this, options);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		RepeatedWritesToSameKey
	)

Definition at line 2448 of file db_test.cc.

References ASSERT_LE, rocksdb::Options::env, env_, RandomString(), value, and rocksdb::Options::write_buffer_size.

                                      {
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
    Reopen(&options);

    // We must have at most one file per level except for level-0,
    // which may have up to kL0_StopWritesTrigger files.
    const int kMaxFiles = dbfull()->NumberLevels() +
      dbfull()->Level0StopWriteTrigger();

    Random rnd(301);
    std::string value = RandomString(&rnd, 2 * options.write_buffer_size);
    for (int i = 0; i < 5 * kMaxFiles; i++) {
      Put("key", value);
      ASSERT_LE(TotalTableFiles(), kMaxFiles);
    }
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		InPlaceUpdate
	)

Definition at line 2469 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::create_if_missing, rocksdb::Options::env, env_, rocksdb::Options::inplace_update_support, rocksdb::Iterator::key(), kTypeValue, rocksdb::Iterator::Next(), rocksdb::Status::ok(), ParseInternalKey(), rocksdb::Iterator::SeekToFirst(), rocksdb::ParsedInternalKey::sequence, rocksdb::Iterator::status(), rocksdb::Iterator::Valid(), value, and rocksdb::Options::write_buffer_size.

                            {
  do {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;

    // Update key with values of smaller size
    Reopen(&options);
    int numValues = 10;
    for (int i = numValues; i > 0; i--) {
      std::string value = DummyString(i, 'a');
      ASSERT_OK(Put("key", value));
      ASSERT_EQ(value, Get("key"));
    }

    int count = 0;
    Iterator* iter = dbfull()->TEST_NewInternalIterator();
    iter->SeekToFirst();
    ASSERT_EQ(iter->status().ok(), true);
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      count++;
      // All updates with the same sequence number.
      ASSERT_EQ(ikey.sequence, (unsigned)1);
      iter->Next();
    }
    // Only 1 instance for that key.
    ASSERT_EQ(count, 1);
    delete iter;

    // Update key with values of larger size
    DestroyAndReopen(&options);
    numValues = 10;
    for (int i = 0; i < numValues; i++) {
      std::string value = DummyString(i, 'a');
      ASSERT_OK(Put("key", value));
      ASSERT_EQ(value, Get("key"));
    }

    count = 0;
    iter = dbfull()->TEST_NewInternalIterator();
    iter->SeekToFirst();
    ASSERT_EQ(iter->status().ok(), true);
    int seq = numValues;
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      count++;
      // No inplace updates. All updates are puts with new seq number
      ASSERT_EQ(ikey.sequence, (unsigned)seq--);
      iter->Next();
    }
    // All 10 updates exist in the internal iterator
    ASSERT_EQ(count, numValues);
    delete iter;


  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		CompactionFilter
	)

Definition at line 2631 of file db_test.cc.

References ASSERT_EQ, ASSERT_NE, ASSERT_OK, cfilter_count, rocksdb::Options::compaction_filter_factory, rocksdb::Options::create_if_missing, db_, rocksdb::Iterator::key(), kTypeValue, rocksdb::Options::max_mem_compaction_level, rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Options::num_levels, ParseInternalKey(), rocksdb::Iterator::SeekToFirst(), rocksdb::ParsedInternalKey::sequence, rocksdb::Iterator::status(), rocksdb::Iterator::Valid(), and value.

                               {
  Options options = CurrentOptions();
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.compaction_filter_factory = std::make_shared<KeepFilterFactory>();
  Reopen(&options);

  // Write 100K keys, these are written to a few files in L0.
  const std::string value(10, 'x');
  for (int i = 0; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%010d", i);
    Put(key, value);
  }
  dbfull()->TEST_FlushMemTable();

  // Push all files to the highest level L2. Verify that
  // the compaction is each level invokes the filter for
  // all the keys in that level.
  cfilter_count = 0;
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
  ASSERT_EQ(cfilter_count, 100000);
  cfilter_count = 0;
  dbfull()->TEST_CompactRange(1, nullptr, nullptr);
  ASSERT_EQ(cfilter_count, 100000);

  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_NE(NumTableFilesAtLevel(2), 0);
  cfilter_count = 0;

  // All the files are in the lowest level.
  // Verify that all but the 100001st record
  // has sequence number zero. The 100001st record
  // is at the tip of this snapshot and cannot
  // be zeroed out.
  // TODO: figure out sequence number squashtoo
  int count = 0;
  int total = 0;
  Iterator* iter = dbfull()->TEST_NewInternalIterator();
  iter->SeekToFirst();
  ASSERT_OK(iter->status());
  while (iter->Valid()) {
    ParsedInternalKey ikey(Slice(), 0, kTypeValue);
    ikey.sequence = -1;
    ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
    total++;
    if (ikey.sequence != 0) {
      count++;
    }
    iter->Next();
  }
  ASSERT_EQ(total, 100000);
  ASSERT_EQ(count, 1);
  delete iter;

  // overwrite all the 100K keys once again.
  for (int i = 0; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%010d", i);
    Put(key, value);
  }
  dbfull()->TEST_FlushMemTable();

  // push all files to the highest level L2. This
  // means that all keys should pass at least once
  // via the compaction filter
  cfilter_count = 0;
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
  ASSERT_EQ(cfilter_count, 100000);
  cfilter_count = 0;
  dbfull()->TEST_CompactRange(1, nullptr, nullptr);
  ASSERT_EQ(cfilter_count, 100000);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_NE(NumTableFilesAtLevel(2), 0);

  // create a new database with the compaction
  // filter in such a way that it deletes all keys
  options.compaction_filter_factory = std::make_shared<DeleteFilterFactory>();
  options.create_if_missing = true;
  DestroyAndReopen(&options);

  // write all the keys once again.
  for (int i = 0; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%010d", i);
    Put(key, value);
  }
  dbfull()->TEST_FlushMemTable();
  ASSERT_NE(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);

  // Push all files to the highest level L2. This
  // triggers the compaction filter to delete all keys,
  // verify that at the end of the compaction process,
  // nothing is left.
  cfilter_count = 0;
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
  ASSERT_EQ(cfilter_count, 100000);
  cfilter_count = 0;
  dbfull()->TEST_CompactRange(1, nullptr, nullptr);
  ASSERT_EQ(cfilter_count, 0);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);

  // Scan the entire database to ensure that nothing is left
  iter = db_->NewIterator(ReadOptions());
  iter->SeekToFirst();
  count = 0;
  while (iter->Valid()) {
    count++;
    iter->Next();
  }
  ASSERT_EQ(count, 0);
  delete iter;

  // The sequence number of the remaining record
  // is not zeroed out even though it is at the
  // level Lmax because this record is at the tip
  // TODO: remove the following or design a different
  // test
  count = 0;
  iter = dbfull()->TEST_NewInternalIterator();
  iter->SeekToFirst();
  ASSERT_OK(iter->status());
  while (iter->Valid()) {
    ParsedInternalKey ikey(Slice(), 0, kTypeValue);
    ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
    ASSERT_NE(ikey.sequence, (unsigned)0);
    count++;
    iter->Next();
  }
  ASSERT_EQ(count, 0);
  delete iter;
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		CompactionFilterWithValueChange
	)

Definition at line 2769 of file db_test.cc.

References ASSERT_EQ, rocksdb::Options::compaction_filter_factory, rocksdb::Options::max_mem_compaction_level, NEW_VALUE, rocksdb::Options::num_levels, and value.

                                              {
  do {
    Options options = CurrentOptions();
    options.num_levels = 3;
    options.max_mem_compaction_level = 0;
    options.compaction_filter_factory =
      std::make_shared<ChangeFilterFactory>(100);
    Reopen(&options);

    // Write 100K+1 keys, these are written to a few files
    // in L0. We do this so that the current snapshot points
    // to the 100001 key.The compaction filter is  not invoked
    // on keys that are visible via a snapshot because we
    // anyways cannot delete it.
    const std::string value(10, 'x');
    for (int i = 0; i < 100001; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
      Put(key, value);
    }

    // push all files to  lower levels
    dbfull()->TEST_FlushMemTable();
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);

    // re-write all data again
    for (int i = 0; i < 100001; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
      Put(key, value);
    }

    // push all files to  lower levels. This should
    // invoke the compaction filter for all 100000 keys.
    dbfull()->TEST_FlushMemTable();
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);

    // verify that all keys now have the new value that
    // was set by the compaction process.
    for (int i = 0; i < 100000; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
      std::string newvalue = Get(key);
      ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
    }
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		SparseMerge
	)

Definition at line 2819 of file db_test.cc.

References ASSERT_LE, rocksdb::Options::compression, kNoCompression, and value.

                          {
  do {
    Options options = CurrentOptions();
    options.compression = kNoCompression;
    Reopen(&options);

    FillLevels("A", "Z");

    // Suppose there is:
    //    small amount of data with prefix A
    //    large amount of data with prefix B
    //    small amount of data with prefix C
    // and that recent updates have made small changes to all three prefixes.
    // Check that we do not do a compaction that merges all of B in one shot.
    const std::string value(1000, 'x');
    Put("A", "va");
    // Write approximately 100MB of "B" values
    for (int i = 0; i < 100000; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
      Put(key, value);
    }
    Put("C", "vc");
    dbfull()->TEST_FlushMemTable();
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);

    // Make sparse update
    Put("A",    "va2");
    Put("B100", "bvalue2");
    Put("C",    "vc2");
    dbfull()->TEST_FlushMemTable();

    // Compactions should not cause us to create a situation where
    // a file overlaps too much data at the next level.
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(), 20*1048576);
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(), 20*1048576);
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(), 20*1048576);
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		ApproximateSizes
	)

Definition at line 2872 of file db_test.cc.

References ASSERT_EQ, ASSERT_GT, ASSERT_OK, ASSERT_TRUE, Between(), rocksdb::Options::compression, kNoCompression, RandomString(), ripple::run(), and rocksdb::Options::write_buffer_size.

                               {
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 100000000;        // Large write buffer
    options.compression = kNoCompression;
    DestroyAndReopen();

    ASSERT_TRUE(Between(Size("", "xyz"), 0, 0));
    Reopen(&options);
    ASSERT_TRUE(Between(Size("", "xyz"), 0, 0));

    // Write 8MB (80 values, each 100K)
    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
    const int N = 80;
    static const int S1 = 100000;
    static const int S2 = 105000;  // Allow some expansion from metadata
    Random rnd(301);
    for (int i = 0; i < N; i++) {
      ASSERT_OK(Put(Key(i), RandomString(&rnd, S1)));
    }

    // 0 because GetApproximateSizes() does not account for memtable space
    ASSERT_TRUE(Between(Size("", Key(50)), 0, 0));

    // Check sizes across recovery by reopening a few times
    for (int run = 0; run < 3; run++) {
      Reopen(&options);

      for (int compact_start = 0; compact_start < N; compact_start += 10) {
        for (int i = 0; i < N; i += 10) {
          ASSERT_TRUE(Between(Size("", Key(i)), S1*i, S2*i));
          ASSERT_TRUE(Between(Size("", Key(i)+".suffix"), S1*(i+1), S2*(i+1)));
          ASSERT_TRUE(Between(Size(Key(i), Key(i+10)), S1*10, S2*10));
        }
        ASSERT_TRUE(Between(Size("", Key(50)), S1*50, S2*50));
        ASSERT_TRUE(Between(Size("", Key(50)+".suffix"), S1*50, S2*50));

        std::string cstart_str = Key(compact_start);
        std::string cend_str = Key(compact_start + 9);
        Slice cstart = cstart_str;
        Slice cend = cend_str;
        dbfull()->TEST_CompactRange(0, &cstart, &cend);
      }

      ASSERT_EQ(NumTableFilesAtLevel(0), 0);
      ASSERT_GT(NumTableFilesAtLevel(1), 0);
    }
  } while (ChangeOptions(kSkipUniversalCompaction));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ApproximateSizes_MixOfSmallAndLarge
	)

Definition at line 2922 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, Between(), rocksdb::Options::compression, kNoCompression, RandomString(), and ripple::run().

                                                  {
  do {
    Options options = CurrentOptions();
    options.compression = kNoCompression;
    Reopen();

    Random rnd(301);
    std::string big1 = RandomString(&rnd, 100000);
    ASSERT_OK(Put(Key(0), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(Key(1), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(Key(2), big1));
    ASSERT_OK(Put(Key(3), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(Key(4), big1));
    ASSERT_OK(Put(Key(5), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(Key(6), RandomString(&rnd, 300000)));
    ASSERT_OK(Put(Key(7), RandomString(&rnd, 10000)));

    // Check sizes across recovery by reopening a few times
    for (int run = 0; run < 3; run++) {
      Reopen(&options);

      ASSERT_TRUE(Between(Size("", Key(0)), 0, 0));
      ASSERT_TRUE(Between(Size("", Key(1)), 10000, 11000));
      ASSERT_TRUE(Between(Size("", Key(2)), 20000, 21000));
      ASSERT_TRUE(Between(Size("", Key(3)), 120000, 121000));
      ASSERT_TRUE(Between(Size("", Key(4)), 130000, 131000));
      ASSERT_TRUE(Between(Size("", Key(5)), 230000, 231000));
      ASSERT_TRUE(Between(Size("", Key(6)), 240000, 241000));
      ASSERT_TRUE(Between(Size("", Key(7)), 540000, 541000));
      ASSERT_TRUE(Between(Size("", Key(8)), 550000, 560000));

      ASSERT_TRUE(Between(Size(Key(3), Key(5)), 110000, 111000));

      dbfull()->TEST_CompactRange(0, nullptr, nullptr);
    }
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		IteratorPinsRef
	)

Definition at line 2960 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db_, rocksdb::Iterator::key(), rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Iterator::SeekToFirst(), rocksdb::Slice::ToString(), rocksdb::Iterator::Valid(), and rocksdb::Iterator::value().

                              {
  do {
    Put("foo", "hello");

    // Get iterator that will yield the current contents of the DB.
    Iterator* iter = db_->NewIterator(ReadOptions());

    // Write to force compactions
    Put("foo", "newvalue1");
    for (int i = 0; i < 100; i++) {
      ASSERT_OK(Put(Key(i), Key(i) + std::string(100000, 'v'))); // 100K values
    }
    Put("foo", "newvalue2");

    iter->SeekToFirst();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ("foo", iter->key().ToString());
    ASSERT_EQ("hello", iter->value().ToString());
    iter->Next();
    ASSERT_TRUE(!iter->Valid());
    delete iter;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		Snapshot
	)

Definition at line 2984 of file db_test.cc.

References ASSERT_EQ, db_, rocksdb::DBImpl::GetSnapshot(), and rocksdb::DBImpl::ReleaseSnapshot().

                       {
  do {
    Put("foo", "v1");
    const Snapshot* s1 = db_->GetSnapshot();
    Put("foo", "v2");
    const Snapshot* s2 = db_->GetSnapshot();
    Put("foo", "v3");
    const Snapshot* s3 = db_->GetSnapshot();

    Put("foo", "v4");
    ASSERT_EQ("v1", Get("foo", s1));
    ASSERT_EQ("v2", Get("foo", s2));
    ASSERT_EQ("v3", Get("foo", s3));
    ASSERT_EQ("v4", Get("foo"));

    db_->ReleaseSnapshot(s3);
    ASSERT_EQ("v1", Get("foo", s1));
    ASSERT_EQ("v2", Get("foo", s2));
    ASSERT_EQ("v4", Get("foo"));

    db_->ReleaseSnapshot(s1);
    ASSERT_EQ("v2", Get("foo", s2));
    ASSERT_EQ("v4", Get("foo"));

    db_->ReleaseSnapshot(s2);
    ASSERT_EQ("v4", Get("foo"));
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		HiddenValuesAreRemoved
	)

Definition at line 3013 of file db_test.cc.

References ASSERT_EQ, ASSERT_GE, ASSERT_GT, ASSERT_OK, ASSERT_TRUE, Between(), db_, rocksdb::DBImpl::GetSnapshot(), RandomString(), and rocksdb::DBImpl::ReleaseSnapshot().

                                     {
  do {
    Random rnd(301);
    FillLevels("a", "z");

    std::string big = RandomString(&rnd, 50000);
    Put("foo", big);
    Put("pastfoo", "v");
    const Snapshot* snapshot = db_->GetSnapshot();
    Put("foo", "tiny");
    Put("pastfoo2", "v2");        // Advance sequence number one more

    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_GT(NumTableFilesAtLevel(0), 0);

    ASSERT_EQ(big, Get("foo", snapshot));
    ASSERT_TRUE(Between(Size("", "pastfoo"), 50000, 60000));
    db_->ReleaseSnapshot(snapshot);
    ASSERT_EQ(AllEntriesFor("foo"), "[ tiny, " + big + " ]");
    Slice x("x");
    dbfull()->TEST_CompactRange(0, nullptr, &x);
    ASSERT_EQ(AllEntriesFor("foo"), "[ tiny ]");
    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
    ASSERT_GE(NumTableFilesAtLevel(1), 1);
    dbfull()->TEST_CompactRange(1, nullptr, &x);
    ASSERT_EQ(AllEntriesFor("foo"), "[ tiny ]");

    ASSERT_TRUE(Between(Size("", "pastfoo"), 0, 1000));
  } while (ChangeOptions(kSkipUniversalCompaction));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		CompactBetweenSnapshots
	)

Definition at line 3044 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::DBImpl::GetSnapshot(), and rocksdb::DBImpl::ReleaseSnapshot().

                                      {
  do {
    Random rnd(301);
    FillLevels("a", "z");

    Put("foo", "first");
    const Snapshot* snapshot1 = db_->GetSnapshot();
    Put("foo", "second");
    Put("foo", "third");
    Put("foo", "fourth");
    const Snapshot* snapshot2 = db_->GetSnapshot();
    Put("foo", "fifth");
    Put("foo", "sixth");

    // All entries (including duplicates) exist
    // before any compaction is triggered.
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ("sixth", Get("foo"));
    ASSERT_EQ("fourth", Get("foo", snapshot2));
    ASSERT_EQ("first", Get("foo", snapshot1));
    ASSERT_EQ(AllEntriesFor("foo"),
              "[ sixth, fifth, fourth, third, second, first ]");

    // After a compaction, "second", "third" and "fifth" should
    // be removed
    FillLevels("a", "z");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ("sixth", Get("foo"));
    ASSERT_EQ("fourth", Get("foo", snapshot2));
    ASSERT_EQ("first", Get("foo", snapshot1));
    ASSERT_EQ(AllEntriesFor("foo"), "[ sixth, fourth, first ]");

    // after we release the snapshot1, only two values left
    db_->ReleaseSnapshot(snapshot1);
    FillLevels("a", "z");
    dbfull()->CompactRange(nullptr, nullptr);

    // We have only one valid snapshot snapshot2. Since snapshot1 is
    // not valid anymore, "first" should be removed by a compaction.
    ASSERT_EQ("sixth", Get("foo"));
    ASSERT_EQ("fourth", Get("foo", snapshot2));
    ASSERT_EQ(AllEntriesFor("foo"), "[ sixth, fourth ]");

    // after we release the snapshot2, only one value should be left
    db_->ReleaseSnapshot(snapshot2);
    FillLevels("a", "z");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ("sixth", Get("foo"));
    ASSERT_EQ(AllEntriesFor("foo"), "[ sixth ]");

  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		DeletionMarkers1
	)

Definition at line 3097 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                               {
  Put("foo", "v1");
  ASSERT_OK(dbfull()->TEST_FlushMemTable());
  const int last = dbfull()->MaxMemCompactionLevel();
  ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo => v1 is now in last level

  // Place a table at level last-1 to prevent merging with preceding mutation
  Put("a", "begin");
  Put("z", "end");
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ(NumTableFilesAtLevel(last), 1);
  ASSERT_EQ(NumTableFilesAtLevel(last-1), 1);

  Delete("foo");
  Put("foo", "v2");
  ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");
  ASSERT_OK(dbfull()->TEST_FlushMemTable());  // Moves to level last-2
  if (CurrentOptions().purge_redundant_kvs_while_flush) {
    ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]");
  } else {
    ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");
  }
  Slice z("z");
  dbfull()->TEST_CompactRange(last-2, nullptr, &z);
  // DEL eliminated, but v1 remains because we aren't compacting that level
  // (DEL can be eliminated because v2 hides v1).
  ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]");
  dbfull()->TEST_CompactRange(last-1, nullptr, nullptr);
  // Merging last-1 w/ last, so we are the base level for "foo", so
  // DEL is removed.  (as is v1).
  ASSERT_EQ(AllEntriesFor("foo"), "[ v2 ]");
}

rocksdb::TEST	(	DBTest	,
		DeletionMarkers2
	)

Definition at line 3130 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                               {
  Put("foo", "v1");
  ASSERT_OK(dbfull()->TEST_FlushMemTable());
  const int last = dbfull()->MaxMemCompactionLevel();
  ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo => v1 is now in last level

  // Place a table at level last-1 to prevent merging with preceding mutation
  Put("a", "begin");
  Put("z", "end");
  dbfull()->TEST_FlushMemTable();
  ASSERT_EQ(NumTableFilesAtLevel(last), 1);
  ASSERT_EQ(NumTableFilesAtLevel(last-1), 1);

  Delete("foo");
  ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
  ASSERT_OK(dbfull()->TEST_FlushMemTable());  // Moves to level last-2
  ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
  dbfull()->TEST_CompactRange(last-2, nullptr, nullptr);
  // DEL kept: "last" file overlaps
  ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
  dbfull()->TEST_CompactRange(last-1, nullptr, nullptr);
  // Merging last-1 w/ last, so we are the base level for "foo", so
  // DEL is removed.  (as is v1).
  ASSERT_EQ(AllEntriesFor("foo"), "[ ]");
}

rocksdb::TEST	(	DBTest	,
		OverlapInLevel0
	)

Definition at line 3156 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                              {
  do {
    int tmp = dbfull()->MaxMemCompactionLevel();
    ASSERT_EQ(tmp, 2) << "Fix test to match config";

    //Fill levels 1 and 2 to disable the pushing of new memtables to levels > 0.
    ASSERT_OK(Put("100", "v100"));
    ASSERT_OK(Put("999", "v999"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_OK(Delete("100"));
    ASSERT_OK(Delete("999"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("0,1,1", FilesPerLevel());

    // Make files spanning the following ranges in level-0:
    //  files[0]  200 .. 900
    //  files[1]  300 .. 500
    // Note that files are sorted by smallest key.
    ASSERT_OK(Put("300", "v300"));
    ASSERT_OK(Put("500", "v500"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_OK(Put("200", "v200"));
    ASSERT_OK(Put("600", "v600"));
    ASSERT_OK(Put("900", "v900"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("2,1,1", FilesPerLevel());

    // Compact away the placeholder files we created initially
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
    dbfull()->TEST_CompactRange(2, nullptr, nullptr);
    ASSERT_EQ("2", FilesPerLevel());

    // Do a memtable compaction.  Before bug-fix, the compaction would
    // not detect the overlap with level-0 files and would incorrectly place
    // the deletion in a deeper level.
    ASSERT_OK(Delete("600"));
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("3", FilesPerLevel());
    ASSERT_EQ("NOT_FOUND", Get("600"));
  } while (ChangeOptions(kSkipUniversalCompaction));
}

rocksdb::TEST	(	DBTest	,
		L0_CompactionBug_Issue44_a
	)

Definition at line 3198 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, env_, and rocksdb::Env::SleepForMicroseconds().

                                         {
  do {
    Reopen();
    ASSERT_OK(Put("b", "v"));
    Reopen();
    ASSERT_OK(Delete("b"));
    ASSERT_OK(Delete("a"));
    Reopen();
    ASSERT_OK(Delete("a"));
    Reopen();
    ASSERT_OK(Put("a", "v"));
    Reopen();
    Reopen();
    ASSERT_EQ("(a->v)", Contents());
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
    ASSERT_EQ("(a->v)", Contents());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		L0_CompactionBug_Issue44_b
	)

Definition at line 3217 of file db_test.cc.

References ASSERT_EQ, env_, and rocksdb::Env::SleepForMicroseconds().

                                         {
  do {
    Reopen();
    Put("","");
    Reopen();
    Delete("e");
    Put("","");
    Reopen();
    Put("c", "cv");
    Reopen();
    Put("","");
    Reopen();
    Put("","");
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
    Reopen();
    Put("d","dv");
    Reopen();
    Put("","");
    Reopen();
    Delete("d");
    Delete("b");
    Reopen();
    ASSERT_EQ("(->)(c->cv)", Contents());
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
    ASSERT_EQ("(->)(c->cv)", Contents());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ComparatorCheck
	)

Definition at line 3245 of file db_test.cc.

References ASSERT_TRUE, BytewiseComparator(), rocksdb::Options::comparator, rocksdb::Comparator::Compare(), rocksdb::Comparator::FindShortestSeparator(), rocksdb::Comparator::FindShortSuccessor(), rocksdb::Status::ok(), and rocksdb::Status::ToString().

                              {
  class NewComparator : public Comparator {
   public:
    virtual const char* Name() const { return "rocksdb.NewComparator"; }
    virtual int Compare(const Slice& a, const Slice& b) const {
      return BytewiseComparator()->Compare(a, b);
    }
    virtual void FindShortestSeparator(std::string* s, const Slice& l) const {
      BytewiseComparator()->FindShortestSeparator(s, l);
    }
    virtual void FindShortSuccessor(std::string* key) const {
      BytewiseComparator()->FindShortSuccessor(key);
    }
  };
  Options new_options;
  NewComparator cmp;
  do {
    new_options = CurrentOptions();
    new_options.comparator = &cmp;
    Status s = TryReopen(&new_options);
    ASSERT_TRUE(!s.ok());
    ASSERT_TRUE(s.ToString().find("comparator") != std::string::npos)
        << s.ToString();
  } while (ChangeCompactOptions(&new_options));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		CustomComparator
	)

Definition at line 3271 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::Options::comparator, rocksdb::Options::create_if_missing, EscapeString(), rocksdb::Options::filter_policy, ripple::run(), rocksdb::Slice::size(), rocksdb::Slice::ToString(), and rocksdb::Options::write_buffer_size.

                               {
  class NumberComparator : public Comparator {
   public:
    virtual const char* Name() const { return "test.NumberComparator"; }
    virtual int Compare(const Slice& a, const Slice& b) const {
      return ToNumber(a) - ToNumber(b);
    }
    virtual void FindShortestSeparator(std::string* s, const Slice& l) const {
      ToNumber(*s);     // Check format
      ToNumber(l);      // Check format
    }
    virtual void FindShortSuccessor(std::string* key) const {
      ToNumber(*key);   // Check format
    }
   private:
    static int ToNumber(const Slice& x) {
      // Check that there are no extra characters.
      ASSERT_TRUE(x.size() >= 2 && x[0] == '[' && x[x.size()-1] == ']')
          << EscapeString(x);
      int val;
      char ignored;
      ASSERT_TRUE(sscanf(x.ToString().c_str(), "[%i]%c", &val, &ignored) == 1)
          << EscapeString(x);
      return val;
    }
  };
  Options new_options;
  NumberComparator cmp;
  do {
    new_options = CurrentOptions();
    new_options.create_if_missing = true;
    new_options.comparator = &cmp;
    new_options.filter_policy = nullptr;     // Cannot use bloom filters
    new_options.write_buffer_size = 1000;  // Compact more often
    DestroyAndReopen(&new_options);
    ASSERT_OK(Put("[10]", "ten"));
    ASSERT_OK(Put("[0x14]", "twenty"));
    for (int i = 0; i < 2; i++) {
      ASSERT_EQ("ten", Get("[10]"));
      ASSERT_EQ("ten", Get("[0xa]"));
      ASSERT_EQ("twenty", Get("[20]"));
      ASSERT_EQ("twenty", Get("[0x14]"));
      ASSERT_EQ("NOT_FOUND", Get("[15]"));
      ASSERT_EQ("NOT_FOUND", Get("[0xf]"));
      Compact("[0]", "[9999]");
    }

    for (int run = 0; run < 2; run++) {
      for (int i = 0; i < 1000; i++) {
        char buf[100];
        snprintf(buf, sizeof(buf), "[%d]", i*10);
        ASSERT_OK(Put(buf, buf));
      }
      Compact("[0]", "[1000000]");
    }
  } while (ChangeCompactOptions(&new_options));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ManualCompaction
	)

Definition at line 3329 of file db_test.cc.

References ASSERT_EQ, rocksdb::DBImpl::CompactRange(), and db_.

                               {
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
      << "Need to update this test to match kMaxMemCompactLevel";

  MakeTables(3, "p", "q");
  ASSERT_EQ("1,1,1", FilesPerLevel());

  // Compaction range falls before files
  Compact("", "c");
  ASSERT_EQ("1,1,1", FilesPerLevel());

  // Compaction range falls after files
  Compact("r", "z");
  ASSERT_EQ("1,1,1", FilesPerLevel());

  // Compaction range overlaps files
  Compact("p1", "p9");
  ASSERT_EQ("0,0,1", FilesPerLevel());

  // Populate a different range
  MakeTables(3, "c", "e");
  ASSERT_EQ("1,1,2", FilesPerLevel());

  // Compact just the new range
  Compact("b", "f");
  ASSERT_EQ("0,0,2", FilesPerLevel());

  // Compact all
  MakeTables(1, "a", "z");
  ASSERT_EQ("0,1,2", FilesPerLevel());
  db_->CompactRange(nullptr, nullptr);
  ASSERT_EQ("0,0,1", FilesPerLevel());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		DBOpen_Options
	)

Definition at line 3363 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, rocksdb::Options::create_if_missing, db, dbname, DestroyDB(), rocksdb::Options::error_if_exists, rocksdb::DB::Open(), rocksdb::test::TmpDir(), and rocksdb::Status::ToString().

                             {
  std::string dbname = test::TmpDir() + "/db_options_test";
  ASSERT_OK(DestroyDB(dbname, Options()));

  // Does not exist, and create_if_missing == false: error
  DB* db = nullptr;
  Options opts;
  opts.create_if_missing = false;
  Status s = DB::Open(opts, dbname, &db);
  ASSERT_TRUE(strstr(s.ToString().c_str(), "does not exist") != nullptr);
  ASSERT_TRUE(db == nullptr);

  // Does not exist, and create_if_missing == true: OK
  opts.create_if_missing = true;
  s = DB::Open(opts, dbname, &db);
  ASSERT_OK(s);
  ASSERT_TRUE(db != nullptr);

  delete db;
  db = nullptr;

  // Does exist, and error_if_exists == true: error
  opts.create_if_missing = false;
  opts.error_if_exists = true;
  s = DB::Open(opts, dbname, &db);
  ASSERT_TRUE(strstr(s.ToString().c_str(), "exists") != nullptr);
  ASSERT_TRUE(db == nullptr);

  // Does exist, and error_if_exists == false: OK
  opts.create_if_missing = true;
  opts.error_if_exists = false;
  s = DB::Open(opts, dbname, &db);
  ASSERT_OK(s);
  ASSERT_TRUE(db != nullptr);

  delete db;
  db = nullptr;
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		DBOpen_Change_NumLevels
	)

Definition at line 3402 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, rocksdb::DB::CompactRange(), rocksdb::Options::create_if_missing, db, dbname, DestroyDB(), rocksdb::Options::num_levels, rocksdb::DB::Open(), rocksdb::DB::Put(), rocksdb::test::TmpDir(), and rocksdb::Status::ToString().

                                      {
  std::string dbname = test::TmpDir() + "/db_change_num_levels";
  ASSERT_OK(DestroyDB(dbname, Options()));
  Options opts;
  Status s;
  DB* db = nullptr;
  opts.create_if_missing = true;
  s = DB::Open(opts, dbname, &db);
  ASSERT_OK(s);
  ASSERT_TRUE(db != nullptr);
  db->Put(WriteOptions(), "a", "123");
  db->Put(WriteOptions(), "b", "234");
  db->CompactRange(nullptr, nullptr);
  delete db;
  db = nullptr;

  opts.create_if_missing = false;
  opts.num_levels = 2;
  s = DB::Open(opts, dbname, &db);
  ASSERT_TRUE(strstr(s.ToString().c_str(), "Corruption") != nullptr);
  ASSERT_TRUE(db == nullptr);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		DestroyDBMetaDatabase
	)

Definition at line 3425 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, rocksdb::Options::create_if_missing, db, dbname, DestroyDB(), MetaDatabaseName(), ripple::Resource::ok, rocksdb::DB::Open(), and rocksdb::test::TmpDir().

                                    {
  std::string dbname = test::TmpDir() + "/db_meta";
  std::string metadbname = MetaDatabaseName(dbname, 0);
  std::string metametadbname = MetaDatabaseName(metadbname, 0);

  // Destroy previous versions if they exist. Using the long way.
  ASSERT_OK(DestroyDB(metametadbname, Options()));
  ASSERT_OK(DestroyDB(metadbname, Options()));
  ASSERT_OK(DestroyDB(dbname, Options()));

  // Setup databases
  Options opts;
  opts.create_if_missing = true;
  DB* db = nullptr;
  ASSERT_OK(DB::Open(opts, dbname, &db));
  delete db;
  db = nullptr;
  ASSERT_OK(DB::Open(opts, metadbname, &db));
  delete db;
  db = nullptr;
  ASSERT_OK(DB::Open(opts, metametadbname, &db));
  delete db;
  db = nullptr;

  // Delete databases
  ASSERT_OK(DestroyDB(dbname, Options()));

  // Check if deletion worked.
  opts.create_if_missing = false;
  ASSERT_TRUE(!(DB::Open(opts, dbname, &db)).ok());
  ASSERT_TRUE(!(DB::Open(opts, metadbname, &db)).ok());
  ASSERT_TRUE(!(DB::Open(opts, metametadbname, &db)).ok());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		NoSpace
	)

Definition at line 3460 of file db_test.cc.

References ASSERT_EQ, ASSERT_GE, ASSERT_LT, ASSERT_OK, rocksdb::Options::env, and env_.

                      {
  do {
    Options options = CurrentOptions();
    options.env = env_;
    Reopen(&options);

    ASSERT_OK(Put("foo", "v1"));
    ASSERT_EQ("v1", Get("foo"));
    Compact("a", "z");
    const int num_files = CountFiles();
    env_->no_space_.Release_Store(env_);   // Force out-of-space errors
    env_->sleep_counter_.Reset();
    for (int i = 0; i < 5; i++) {
      for (int level = 0; level < dbfull()->NumberLevels()-1; level++) {
        dbfull()->TEST_CompactRange(level, nullptr, nullptr);
      }
    }
    env_->no_space_.Release_Store(nullptr);
    ASSERT_LT(CountFiles(), num_files + 3);

    // Check that compaction attempts slept after errors
    ASSERT_GE(env_->sleep_counter_.Read(), 5);
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		NonWritableFileSystem
	)

Definition at line 3485 of file db_test.cc.

References ASSERT_GT, ASSERT_OK, rocksdb::Options::env, env_, ripple::Resource::ok, rocksdb::Env::SleepForMicroseconds(), and rocksdb::Options::write_buffer_size.

                                    {
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 1000;
    options.env = env_;
    Reopen(&options);
    ASSERT_OK(Put("foo", "v1"));
    env_->non_writable_.Release_Store(env_); // Force errors for new files
    std::string big(100000, 'x');
    int errors = 0;
    for (int i = 0; i < 20; i++) {
      if (!Put("foo", big).ok()) {
        errors++;
        env_->SleepForMicroseconds(100000);
      }
    }
    ASSERT_GT(errors, 0);
    env_->non_writable_.Release_Store(nullptr);
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ManifestWriteError
	)

Definition at line 3506 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::env, env_, and rocksdb::port::AtomicPointer::Release_Store().

                                 {
  // Test for the following problem:
  // (a) Compaction produces file F
  // (b) Log record containing F is written to MANIFEST file, but Sync() fails
  // (c) GC deletes F
  // (d) After reopening DB, reads fail since deleted F is named in log record

  // We iterate twice.  In the second iteration, everything is the
  // same except the log record never makes it to the MANIFEST file.
  for (int iter = 0; iter < 2; iter++) {
    port::AtomicPointer* error_type = (iter == 0)
        ? &env_->manifest_sync_error_
        : &env_->manifest_write_error_;

    // Insert foo=>bar mapping
    Options options = CurrentOptions();
    options.env = env_;
    options.create_if_missing = true;
    options.error_if_exists = false;
    DestroyAndReopen(&options);
    ASSERT_OK(Put("foo", "bar"));
    ASSERT_EQ("bar", Get("foo"));

    // Memtable compaction (will succeed)
    dbfull()->TEST_FlushMemTable();
    ASSERT_EQ("bar", Get("foo"));
    const int last = dbfull()->MaxMemCompactionLevel();
    ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo=>bar is now in last level

    // Merging compaction (will fail)
    error_type->Release_Store(env_);
    dbfull()->TEST_CompactRange(last, nullptr, nullptr);  // Should fail
    ASSERT_EQ("bar", Get("foo"));

    // Recovery: should not lose data
    error_type->Release_Store(nullptr);
    Reopen(&options);
    ASSERT_EQ("bar", Get("foo"));
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		PutFailsParanoid
	)

Definition at line 3547 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, rocksdb::Options::create_if_missing, rocksdb::Options::env, env_, rocksdb::Options::error_if_exists, rocksdb::Status::ok(), and rocksdb::Options::paranoid_checks.

                               {
  // Test the following:
  // (a) A random put fails in paranoid mode (simulate by sync fail)
  // (b) All other puts have to fail, even if writes would succeed
  // (c) All of that should happen ONLY if paranoid_checks = true

  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.error_if_exists = false;
  options.paranoid_checks = true;
  DestroyAndReopen(&options);
  Status s;

  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Put("foo1", "bar1"));
  // simulate error
  env_->log_write_error_.Release_Store(env_);
  s = Put("foo2", "bar2");
  ASSERT_TRUE(!s.ok());
  env_->log_write_error_.Release_Store(nullptr);
  s = Put("foo3", "bar3");
  // the next put should fail, too
  ASSERT_TRUE(!s.ok());
  // but we're still able to read
  ASSERT_EQ("bar", Get("foo"));

  // do the same thing with paranoid checks off
  options.paranoid_checks = false;
  DestroyAndReopen(&options);

  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Put("foo1", "bar1"));
  // simulate error
  env_->log_write_error_.Release_Store(env_);
  s = Put("foo2", "bar2");
  ASSERT_TRUE(!s.ok());
  env_->log_write_error_.Release_Store(nullptr);
  s = Put("foo3", "bar3");
  // the next put should NOT fail
  ASSERT_TRUE(s.ok());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		FilesDeletedAfterCompaction
	)

Definition at line 3590 of file db_test.cc.

References ASSERT_EQ, and ASSERT_OK.

                                          {
  do {
    ASSERT_OK(Put("foo", "v2"));
    Compact("a", "z");
    const int num_files = CountLiveFiles();
    for (int i = 0; i < 10; i++) {
      ASSERT_OK(Put("foo", "v2"));
      Compact("a", "z");
    }
    ASSERT_EQ(CountLiveFiles(), num_files);
  } while (ChangeCompactOptions());
}

rocksdb::TEST	(	DBTest	,
		BloomFilter
	)

Definition at line 3603 of file db_test.cc.

References ASSERT_EQ, ASSERT_GE, ASSERT_LE, ASSERT_OK, rocksdb::Options::env, env_, rocksdb::Options::filter_policy, NewBloomFilterPolicy(), and rocksdb::Options::no_block_cache.

                          {
  do {
    env_->count_random_reads_ = true;
    Options options = CurrentOptions();
    options.env = env_;
    options.no_block_cache = true;
    options.filter_policy = NewBloomFilterPolicy(10);
    Reopen(&options);

    // Populate multiple layers
    const int N = 10000;
    for (int i = 0; i < N; i++) {
      ASSERT_OK(Put(Key(i), Key(i)));
    }
    Compact("a", "z");
    for (int i = 0; i < N; i += 100) {
      ASSERT_OK(Put(Key(i), Key(i)));
    }
    dbfull()->TEST_FlushMemTable();

    // Prevent auto compactions triggered by seeks
    env_->delay_sstable_sync_.Release_Store(env_);

    // Lookup present keys.  Should rarely read from small sstable.
    env_->random_read_counter_.Reset();
    for (int i = 0; i < N; i++) {
      ASSERT_EQ(Key(i), Get(Key(i)));
    }
    int reads = env_->random_read_counter_.Read();
    fprintf(stderr, "%d present => %d reads\n", N, reads);
    ASSERT_GE(reads, N);
    ASSERT_LE(reads, N + 2*N/100);

    // Lookup present keys.  Should rarely read from either sstable.
    env_->random_read_counter_.Reset();
    for (int i = 0; i < N; i++) {
      ASSERT_EQ("NOT_FOUND", Get(Key(i) + ".missing"));
    }
    reads = env_->random_read_counter_.Read();
    fprintf(stderr, "%d missing => %d reads\n", N, reads);
    ASSERT_LE(reads, 3*N/100);

    env_->delay_sstable_sync_.Release_Store(nullptr);
    Close();
    delete options.filter_policy;
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		SnapshotFiles
	)

Definition at line 3651 of file db_test.cc.

References ASSERT_EQ, ASSERT_GE, ASSERT_GT, ASSERT_OK, ripple::compare(), rocksdb::Options::create_if_missing, dbname_, rocksdb::DB::DisableFileDeletions(), env_, rocksdb::DB::Get(), rocksdb::Env::GetFileSize(), kDescriptorFile, ripple::min(), rocksdb::Env::NewSequentialFile(), rocksdb::Env::NewWritableFile(), rocksdb::DB::Open(), ParseFileName(), RandomString(), rocksdb::SequentialFile::Read(), rocksdb::Slice::size(), and rocksdb::Options::write_buffer_size.

                            {
  do {
    Options options = CurrentOptions();
    const EnvOptions soptions;
    options.write_buffer_size = 100000000;        // Large write buffer
    Reopen(&options);

    Random rnd(301);

    // Write 8MB (80 values, each 100K)
    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
    std::vector<std::string> values;
    for (int i = 0; i < 80; i++) {
      values.push_back(RandomString(&rnd, 100000));
      ASSERT_OK(Put(Key(i), values[i]));
    }

    // assert that nothing makes it to disk yet.
    ASSERT_EQ(NumTableFilesAtLevel(0), 0);

    // get a file snapshot
    uint64_t manifest_number = 0;
    uint64_t manifest_size = 0;
    std::vector<std::string> files;
    dbfull()->DisableFileDeletions();
    dbfull()->GetLiveFiles(files, &manifest_size);

    // CURRENT, MANIFEST, *.sst files
    ASSERT_EQ(files.size(), 3U);

    uint64_t number = 0;
    FileType type;

    // copy these files to a new snapshot directory
    std::string snapdir = dbname_ + ".snapdir/";
    std::string mkdir = "mkdir -p " + snapdir;
    ASSERT_EQ(system(mkdir.c_str()), 0);

    for (unsigned int i = 0; i < files.size(); i++) {
      // our clients require that GetLiveFiles returns
      // files with "/" as first character!
      ASSERT_EQ(files[i][0], '/');
      std::string src = dbname_ + files[i];
      std::string dest = snapdir + files[i];

      uint64_t size;
      ASSERT_OK(env_->GetFileSize(src, &size));

      // record the number and the size of the
      // latest manifest file
      if (ParseFileName(files[i].substr(1), &number, &type)) {
        if (type == kDescriptorFile) {
          if (number > manifest_number) {
            manifest_number = number;
            ASSERT_GE(size, manifest_size);
            size = manifest_size; // copy only valid MANIFEST data
          }
        }
      }
      unique_ptr<SequentialFile> srcfile;
      ASSERT_OK(env_->NewSequentialFile(src, &srcfile, soptions));
      unique_ptr<WritableFile> destfile;
      ASSERT_OK(env_->NewWritableFile(dest, &destfile, soptions));

      char buffer[4096];
      Slice slice;
      while (size > 0) {
        uint64_t one = std::min(uint64_t(sizeof(buffer)), size);
        ASSERT_OK(srcfile->Read(one, &slice, buffer));
        ASSERT_OK(destfile->Append(slice));
        size -= slice.size();
      }
      ASSERT_OK(destfile->Close());
    }

    // release file snapshot
    dbfull()->DisableFileDeletions();

    // overwrite one key, this key should not appear in the snapshot
    std::vector<std::string> extras;
    for (unsigned int i = 0; i < 1; i++) {
      extras.push_back(RandomString(&rnd, 100000));
      ASSERT_OK(Put(Key(i), extras[i]));
    }

    // verify that data in the snapshot are correct
    Options opts;
    DB* snapdb;
    opts.create_if_missing = false;
    Status stat = DB::Open(opts, snapdir, &snapdb);
    ASSERT_OK(stat);

    ReadOptions roptions;
    std::string val;
    for (unsigned int i = 0; i < 80; i++) {
      stat = snapdb->Get(roptions, Key(i), &val);
      ASSERT_EQ(values[i].compare(val), 0);
    }
    delete snapdb;

    // look at the new live files after we added an 'extra' key
    // and after we took the first snapshot.
    uint64_t new_manifest_number = 0;
    uint64_t new_manifest_size = 0;
    std::vector<std::string> newfiles;
    dbfull()->DisableFileDeletions();
    dbfull()->GetLiveFiles(newfiles, &new_manifest_size);

    // find the new manifest file. assert that this manifest file is
    // the same one as in the previous snapshot. But its size should be
    // larger because we added an extra key after taking the
    // previous shapshot.
    for (unsigned int i = 0; i < newfiles.size(); i++) {
      std::string src = dbname_ + "/" + newfiles[i];
      // record the lognumber and the size of the
      // latest manifest file
      if (ParseFileName(newfiles[i].substr(1), &number, &type)) {
        if (type == kDescriptorFile) {
          if (number > new_manifest_number) {
            uint64_t size;
            new_manifest_number = number;
            ASSERT_OK(env_->GetFileSize(src, &size));
            ASSERT_GE(size, new_manifest_size);
          }
        }
      }
    }
    ASSERT_EQ(manifest_number, new_manifest_number);
    ASSERT_GT(new_manifest_size, manifest_size);

    // release file snapshot
    dbfull()->DisableFileDeletions();
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		CompactOnFlush
	)

Definition at line 3786 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, db_, rocksdb::Options::disable_auto_compactions, rocksdb::DBImpl::GetSnapshot(), rocksdb::Options::purge_redundant_kvs_while_flush, and rocksdb::DBImpl::ReleaseSnapshot().

                             {
  do {
    Options options = CurrentOptions();
    options.purge_redundant_kvs_while_flush = true;
    options.disable_auto_compactions = true;
    Reopen(&options);

    Put("foo", "v1");
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ v1 ]");

    // Write two new keys
    Put("a", "begin");
    Put("z", "end");
    dbfull()->TEST_FlushMemTable();

    // Case1: Delete followed by a put
    Delete("foo");
    Put("foo", "v2");
    ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");

    // After the current memtable is flushed, the DEL should
    // have been removed
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]");

    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ(AllEntriesFor("foo"), "[ v2 ]");

    // Case 2: Delete followed by another delete
    Delete("foo");
    Delete("foo");
    ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, DEL, v2 ]");
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v2 ]");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ(AllEntriesFor("foo"), "[ ]");

    // Case 3: Put followed by a delete
    Put("foo", "v3");
    Delete("foo");
    ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v3 ]");
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ DEL ]");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ(AllEntriesFor("foo"), "[ ]");

    // Case 4: Put followed by another Put
    Put("foo", "v4");
    Put("foo", "v5");
    ASSERT_EQ(AllEntriesFor("foo"), "[ v5, v4 ]");
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ v5 ]");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ(AllEntriesFor("foo"), "[ v5 ]");

    // clear database
    Delete("foo");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ(AllEntriesFor("foo"), "[ ]");

    // Case 5: Put followed by snapshot followed by another Put
    // Both puts should remain.
    Put("foo", "v6");
    const Snapshot* snapshot = db_->GetSnapshot();
    Put("foo", "v7");
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ v7, v6 ]");
    db_->ReleaseSnapshot(snapshot);

    // clear database
    Delete("foo");
    dbfull()->CompactRange(nullptr, nullptr);
    ASSERT_EQ(AllEntriesFor("foo"), "[ ]");

    // Case 5: snapshot followed by a put followed by another Put
    // Only the last put should remain.
    const Snapshot* snapshot1 = db_->GetSnapshot();
    Put("foo", "v8");
    Put("foo", "v9");
    ASSERT_OK(dbfull()->TEST_FlushMemTable());
    ASSERT_EQ(AllEntriesFor("foo"), "[ v9 ]");
    db_->ReleaseSnapshot(snapshot1);
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		WALArchivalTtl
	)

Definition at line 3888 of file db_test.cc.

References ArchivalDirectory(), ASSERT_OK, ASSERT_TRUE, rocksdb::Options::create_if_missing, dbname_, env_, ListLogFiles(), rocksdb::Env::SleepForMicroseconds(), and rocksdb::Options::WAL_ttl_seconds.

                             {
  do {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.WAL_ttl_seconds = 1000;
    DestroyAndReopen(&options);

    //  TEST : Create DB with a ttl and no size limit.
    //  Put some keys. Count the log files present in the DB just after insert.
    //  Re-open db. Causes deletion/archival to take place.
    //  Assert that the files moved under "/archive".
    //  Reopen db with small ttl.
    //  Assert that archive was removed.

    std::string archiveDir = ArchivalDirectory(dbname_);

    for (int i = 0; i < 10; ++i) {
      for (int j = 0; j < 10; ++j) {
        ASSERT_OK(Put(Key(10 * i + j), DummyString(1024)));
      }

      std::vector<uint64_t> log_files = ListLogFiles(env_, dbname_);

      options.create_if_missing = false;
      Reopen(&options);

      std::vector<uint64_t> logs = ListLogFiles(env_, archiveDir);
      std::set<uint64_t> archivedFiles(logs.begin(), logs.end());

      for (auto& log : log_files) {
        ASSERT_TRUE(archivedFiles.find(log) != archivedFiles.end());
      }
    }

    std::vector<uint64_t> log_files = ListLogFiles(env_, archiveDir);
    ASSERT_TRUE(log_files.size() > 0);

    options.WAL_ttl_seconds = 1;
    env_->SleepForMicroseconds(2 * 1000 * 1000);
    Reopen(&options);

    log_files = ListLogFiles(env_, archiveDir);
    ASSERT_TRUE(log_files.empty());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		WALArchivalSizeLimit
	)

Definition at line 3951 of file db_test.cc.

References ArchivalDirectory(), ASSERT_OK, ASSERT_TRUE, rocksdb::Options::create_if_missing, dbname_, env_, GetLogDirSize(), ListLogFiles(), rocksdb::Env::SleepForMicroseconds(), rocksdb::Options::WAL_size_limit_MB, and rocksdb::Options::WAL_ttl_seconds.

                                   {
  do {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.WAL_ttl_seconds = 0;
    options.WAL_size_limit_MB = 1000;

    // TEST : Create DB with huge size limit and no ttl.
    // Put some keys. Count the archived log files present in the DB
    // just after insert. Assert that there are many enough.
    // Change size limit. Re-open db.
    // Assert that archive is not greater than WAL_size_limit_MB.
    // Set ttl and time_to_check_ to small values. Re-open db.
    // Assert that there are no archived logs left.

    DestroyAndReopen(&options);
    for (int i = 0; i < 128 * 128; ++i) {
      ASSERT_OK(Put(Key(i), DummyString(1024)));
    }
    Reopen(&options);

    std::string archive_dir = ArchivalDirectory(dbname_);
    std::vector<std::uint64_t> log_files = ListLogFiles(env_, archive_dir);
    ASSERT_TRUE(log_files.size() > 2);

    options.WAL_size_limit_MB = 8;
    Reopen(&options);
    dbfull()->TEST_PurgeObsoleteteWAL();

    uint64_t archive_size = GetLogDirSize(archive_dir, env_);
    ASSERT_TRUE(archive_size <= options.WAL_size_limit_MB * 1024 * 1024);

    options.WAL_ttl_seconds = 1;
    dbfull()->TEST_SetDefaultTimeToCheck(1);
    env_->SleepForMicroseconds(2 * 1000 * 1000);
    Reopen(&options);
    dbfull()->TEST_PurgeObsoleteteWAL();

    log_files = ListLogFiles(env_, archive_dir);
    ASSERT_TRUE(log_files.empty());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIterator
	)

Definition at line 4019 of file db_test.cc.

References ASSERT_EQ, env_, ExpectRecords(), and rocksdb::Env::SleepForMicroseconds().

                                     {
  do {
    Options options = OptionsForLogIterTest();
    DestroyAndReopen(&options);
    Put("key1", DummyString(1024));
    Put("key2", DummyString(1024));
    Put("key2", DummyString(1024));
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3U);
    {
      auto iter = OpenTransactionLogIter(0);
      ExpectRecords(3, iter);
    }
    Reopen(&options);
      env_->SleepForMicroseconds(2 * 1000 * 1000);{
      Put("key4", DummyString(1024));
      Put("key5", DummyString(1024));
      Put("key6", DummyString(1024));
    }
    {
      auto iter = OpenTransactionLogIter(0);
      ExpectRecords(6, iter);
    }
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIteratorMoveOverZeroFiles
	)

Definition at line 4044 of file db_test.cc.

References ExpectRecords().

                                                      {
  do {
    Options options = OptionsForLogIterTest();
    DestroyAndReopen(&options);
    // Do a plain Reopen.
    Put("key1", DummyString(1024));
    // Two reopens should create a zero record WAL file.
    Reopen(&options);
    Reopen(&options);

    Put("key2", DummyString(1024));

    auto iter = OpenTransactionLogIter(0);
    ExpectRecords(2, iter);
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIteratorJustEmptyFile
	)

Definition at line 4083 of file db_test.cc.

References ASSERT_TRUE, and rocksdb::TransactionLogIterator::Valid().

                                                  {
  do {
    Options options = OptionsForLogIterTest();
    DestroyAndReopen(&options);
    unique_ptr<TransactionLogIterator> iter;
    Status status = dbfull()->GetUpdatesSince(0, &iter);
    // Check that an empty iterator is returned
    ASSERT_TRUE(!iter->Valid());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIteratorCheckAfterRestart
	)

Definition at line 4094 of file db_test.cc.

References ExpectRecords().

                                                      {
  do {
    Options options = OptionsForLogIterTest();
    DestroyAndReopen(&options);
    Put("key1", DummyString(1024));
    Put("key2", DummyString(1023));
    dbfull()->Flush(FlushOptions());
    Reopen(&options);
    auto iter = OpenTransactionLogIter(0);
    ExpectRecords(2, iter);
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIteratorCorruptedLog
	)

Definition at line 4107 of file db_test.cc.

References ASSERT_EQ, ASSERT_LT, ASSERT_OK, dbname_, ExpectRecords(), ReadRecords(), and beast::IP::to_string().

                                                 {
  do {
    Options options = OptionsForLogIterTest();
    DestroyAndReopen(&options);
    for (int i = 0; i < 1024; i++) {
      Put("key"+std::to_string(i), DummyString(10));
    }
    dbfull()->Flush(FlushOptions());
    // Corrupt this log to create a gap
    rocksdb::VectorLogPtr wal_files;
    ASSERT_OK(dbfull()->GetSortedWalFiles(wal_files));
    const auto logfilePath = dbname_ + "/" + wal_files.front()->PathName();
    ASSERT_EQ(
      0,
      truncate(logfilePath.c_str(), wal_files.front()->SizeFileBytes() / 2));
    // Insert a new entry to a new log file
    Put("key1025", DummyString(10));
    // Try to read from the beginning. Should stop before the gap and read less
    // than 1025 entries
    auto iter = OpenTransactionLogIter(0);
    int count;
    int last_sequence_read = ReadRecords(iter, count);
    ASSERT_LT(last_sequence_read, 1025);
    // Try to read past the gap, should be able to seek to key1025
    auto iter2 = OpenTransactionLogIter(last_sequence_read + 1);
    ExpectRecords(1, iter2);
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIteratorBatchOperations
	)

Definition at line 4136 of file db_test.cc.

References rocksdb::WriteBatch::Delete(), ExpectRecords(), and rocksdb::WriteBatch::Put().

                                                    {
  do {
    Options options = OptionsForLogIterTest();
    DestroyAndReopen(&options);
    WriteBatch batch;
    batch.Put("key1", DummyString(1024));
    batch.Put("key2", DummyString(1024));
    batch.Put("key3", DummyString(1024));
    batch.Delete("key2");
    dbfull()->Write(WriteOptions(), &batch);
    dbfull()->Flush(FlushOptions());
    Reopen(&options);
    Put("key4", DummyString(1024));
    auto iter = OpenTransactionLogIter(3);
    ExpectRecords(2, iter);
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		TransactionLogIteratorBlobs
	)

Definition at line 4154 of file db_test.cc.

References ASSERT_EQ, rocksdb::WriteBatch::Delete(), rocksdb::WriteBatch::Put(), rocksdb::WriteBatch::PutLogData(), seen, rocksdb::Slice::size(), beast::IP::to_string(), rocksdb::Slice::ToString(), and value.

                                          {
  Options options = OptionsForLogIterTest();
  DestroyAndReopen(&options);
  {
    WriteBatch batch;
    batch.Put("key1", DummyString(1024));
    batch.Put("key2", DummyString(1024));
    batch.PutLogData(Slice("blob1"));
    batch.Put("key3", DummyString(1024));
    batch.PutLogData(Slice("blob2"));
    batch.Delete("key2");
    dbfull()->Write(WriteOptions(), &batch);
    Reopen(&options);
  }

  auto res = OpenTransactionLogIter(0)->GetBatch();
  struct Handler : public WriteBatch::Handler {
    std::string seen;
    virtual void Put(const Slice& key, const Slice& value) {
      seen += "Put(" + key.ToString() + ", " + std::to_string(value.size()) +
        ")";
    }
    virtual void Merge(const Slice& key, const Slice& value) {
      seen += "Merge(" + key.ToString() + ", " + std::to_string(value.size()) +
        ")";
    }
    virtual void LogData(const Slice& blob) {
      seen += "LogData(" + blob.ToString() + ")";
    }
    virtual void Delete(const Slice& key) {
      seen += "Delete(" + key.ToString() + ")";
    }
  } handler;
  res.writeBatchPtr->Iterate(&handler);
  ASSERT_EQ("Put(key1, 1024)"
            "Put(key2, 1024)"
            "LogData(blob1)"
            "Put(key3, 1024)"
            "LogData(blob2)"
            "Delete(key2)", handler.seen);
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		ReadCompaction
	)

Definition at line 4196 of file db_test.cc.

References ASSERT_EQ, ASSERT_NE, ASSERT_OK, ASSERT_TRUE, rocksdb::Options::block_size, rocksdb::Options::create_if_missing, env_, rocksdb::Options::filter_policy, rocksdb::Options::max_open_files, rocksdb::Options::no_block_cache, rocksdb::Env::SleepForMicroseconds(), rocksdb::Options::target_file_size_base, value, and rocksdb::Options::write_buffer_size.

                             {
  std::string value(4096, '4'); // a string of size 4K
  {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.max_open_files = 20; // only 10 file in file-cache
    options.target_file_size_base = 512;
    options.write_buffer_size = 64 * 1024;
    options.filter_policy = nullptr;
    options.block_size = 4096;
    options.no_block_cache = true;

    Reopen(&options);

    // Write 8MB (2000 values, each 4K)
    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
    std::vector<std::string> values;
    for (int i = 0; i < 2000; i++) {
      ASSERT_OK(Put(Key(i), value));
    }

    // clear level 0 and 1 if necessary.
    dbfull()->TEST_FlushMemTable();
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
    ASSERT_EQ(NumTableFilesAtLevel(1), 0);

    // write some new keys into level 0
    for (int i = 0; i < 2000; i = i + 16) {
      ASSERT_OK(Put(Key(i), value));
    }
    dbfull()->Flush(FlushOptions());

    // Wait for any write compaction to finish
    dbfull()->TEST_WaitForCompact();

    // remember number of files in each level
    int l1 = NumTableFilesAtLevel(0);
    int l2 = NumTableFilesAtLevel(1);
    int l3 = NumTableFilesAtLevel(3);
    ASSERT_NE(NumTableFilesAtLevel(0), 0);
    ASSERT_NE(NumTableFilesAtLevel(1), 0);
    ASSERT_NE(NumTableFilesAtLevel(2), 0);

    // read a bunch of times, trigger read compaction
    for (int j = 0; j < 100; j++) {
      for (int i = 0; i < 2000; i++) {
        Get(Key(i));
      }
    }
    // wait for read compaction to finish
    env_->SleepForMicroseconds(1000000);

    // verify that the number of files have decreased
    // in some level, indicating that there was a compaction
    ASSERT_TRUE(NumTableFilesAtLevel(0) < l1 ||
                NumTableFilesAtLevel(1) < l2 ||
                NumTableFilesAtLevel(2) < l3);
  }
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		MultiThreaded
	)

Definition at line 4324 of file db_test.cc.

References env_, id, rocksdb::Env::SleepForMicroseconds(), and rocksdb::Env::StartThread().

                            {
  do {
    // Initialize state
    MTState mt;
    mt.test = this;
    mt.stop.Release_Store(0);
    for (int id = 0; id < kNumThreads; id++) {
      mt.counter[id].Release_Store(0);
      mt.thread_done[id].Release_Store(0);
    }

    // Start threads
    MTThread thread[kNumThreads];
    for (int id = 0; id < kNumThreads; id++) {
      thread[id].state = &mt;
      thread[id].id = id;
      env_->StartThread(MTThreadBody, &thread[id]);
    }

    // Let them run for a while
    env_->SleepForMicroseconds(kTestSeconds * 1000000);

    // Stop the threads and wait for them to finish
    mt.stop.Release_Store(&mt);
    for (int id = 0; id < kNumThreads; id++) {
      while (mt.thread_done[id].Acquire_Load() == nullptr) {
        env_->SleepForMicroseconds(100000);
      }
    }
  } while (ChangeOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		Randomized
	)

Definition at line 4589 of file db_test.cc.

References ASSERT_OK, ASSERT_TRUE, CompareIterators(), db_, rocksdb::DBImpl::Delete(), rocksdb::WriteBatch::Delete(), rocksdb::ModelDB::Delete(), rocksdb::DBImpl::GetSnapshot(), rocksdb::ModelDB::GetSnapshot(), rocksdb::Random::OneIn(), rocksdb::DBImpl::Put(), rocksdb::WriteBatch::Put(), rocksdb::ModelDB::Put(), RandomKey(), rocksdb::test::RandomSeed(), RandomString(), rocksdb::DBImpl::ReleaseSnapshot(), rocksdb::ModelDB::ReleaseSnapshot(), rocksdb::Random::Uniform(), rocksdb::DBImpl::Write(), and rocksdb::ModelDB::Write().

                         {
  Random rnd(test::RandomSeed());
  do {
    ModelDB model(CurrentOptions());
    const int N = 10000;
    const Snapshot* model_snap = nullptr;
    const Snapshot* db_snap = nullptr;
    std::string k, v;
    for (int step = 0; step < N; step++) {
      // TODO(sanjay): Test Get() works
      int p = rnd.Uniform(100);
      int minimum = 0;
      if (option_config_ == kPrefixHashRep) {
        minimum = 1;
      }
      if (p < 45) {                               // Put
        k = RandomKey(&rnd, minimum);
        v = RandomString(&rnd,
                         rnd.OneIn(20)
                         ? 100 + rnd.Uniform(100)
                         : rnd.Uniform(8));
        ASSERT_OK(model.Put(WriteOptions(), k, v));
        ASSERT_OK(db_->Put(WriteOptions(), k, v));

      } else if (p < 90) {                        // Delete
        k = RandomKey(&rnd, minimum);
        ASSERT_OK(model.Delete(WriteOptions(), k));
        ASSERT_OK(db_->Delete(WriteOptions(), k));


      } else {                                    // Multi-element batch
        WriteBatch b;
        const int num = rnd.Uniform(8);
        for (int i = 0; i < num; i++) {
          if (i == 0 || !rnd.OneIn(10)) {
            k = RandomKey(&rnd, minimum);
          } else {
            // Periodically re-use the same key from the previous iter, so
            // we have multiple entries in the write batch for the same key
          }
          if (rnd.OneIn(2)) {
            v = RandomString(&rnd, rnd.Uniform(10));
            b.Put(k, v);
          } else {
            b.Delete(k);
          }
        }
        ASSERT_OK(model.Write(WriteOptions(), &b));
        ASSERT_OK(db_->Write(WriteOptions(), &b));
      }

      if ((step % 100) == 0) {
        ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));
        ASSERT_TRUE(CompareIterators(step, &model, db_, model_snap, db_snap));
        // Save a snapshot from each DB this time that we'll use next
        // time we compare things, to make sure the current state is
        // preserved with the snapshot
        if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
        if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);

        Reopen();
        ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));

        model_snap = model.GetSnapshot();
        db_snap = db_->GetSnapshot();
      }
    }
    if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
    if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
  } while (ChangeOptions(kSkipDeletesFilterFirst));
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		MultiGetSimple
	)

Definition at line 4661 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, ASSERT_TRUE, db_, rocksdb::DBImpl::Delete(), rocksdb::DBImpl::MultiGet(), and rocksdb::DBImpl::Put().

                             {
  do {
    ASSERT_OK(db_->Put(WriteOptions(),"k1","v1"));
    ASSERT_OK(db_->Put(WriteOptions(),"k2","v2"));
    ASSERT_OK(db_->Put(WriteOptions(),"k3","v3"));
    ASSERT_OK(db_->Put(WriteOptions(),"k4","v4"));
    ASSERT_OK(db_->Delete(WriteOptions(),"k4"));
    ASSERT_OK(db_->Put(WriteOptions(),"k5","v5"));
    ASSERT_OK(db_->Delete(WriteOptions(),"no_key"));

    std::vector<Slice> keys(6);
    keys[0] = "k1";
    keys[1] = "k2";
    keys[2] = "k3";
    keys[3] = "k4";
    keys[4] = "k5";
    keys[5] = "no_key";

    std::vector<std::string> values(20,"Temporary data to be overwritten");

    std::vector<Status> s =  db_->MultiGet(ReadOptions(),keys,&values);
    ASSERT_EQ(values.size(),keys.size());
    ASSERT_EQ(values[0], "v1");
    ASSERT_EQ(values[1], "v2");
    ASSERT_EQ(values[2], "v3");
    ASSERT_EQ(values[4], "v5");

    ASSERT_OK(s[0]);
    ASSERT_OK(s[1]);
    ASSERT_OK(s[2]);
    ASSERT_TRUE(s[3].IsNotFound());
    ASSERT_OK(s[4]);
    ASSERT_TRUE(s[5].IsNotFound());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		MultiGetEmpty
	)

Definition at line 4697 of file db_test.cc.

References ASSERT_EQ, ASSERT_TRUE, db_, and rocksdb::DBImpl::MultiGet().

                            {
  do {
    // Empty Key Set
    std::vector<Slice> keys;
    std::vector<std::string> values;
    std::vector<Status> s = db_->MultiGet(ReadOptions(),keys,&values);
    ASSERT_EQ((int)s.size(),0);

    // Empty Database, Empty Key Set
    DestroyAndReopen();
    s = db_->MultiGet(ReadOptions(), keys, &values);
    ASSERT_EQ((int)s.size(),0);

    // Empty Database, Search for Keys
    keys.resize(2);
    keys[0] = "a";
    keys[1] = "b";
    s = db_->MultiGet(ReadOptions(),keys,&values);
    ASSERT_EQ((int)s.size(), 2);
    ASSERT_TRUE(s[0].IsNotFound() && s[1].IsNotFound());
  } while (ChangeCompactOptions());
}

Here is the call graph for this function:

rocksdb::TEST	(	DBTest	,
		PrefixScan
	)

Definition at line 4770 of file db_test.cc.

References ASSERT_EQ, ASSERT_OK, rocksdb::Options::create_if_missing, db_, rocksdb::Options::disable_auto_compactions, rocksdb::Options::disable_seek_compaction, rocksdb::Options::env, env_, rocksdb::Options::filter_policy, rocksdb::Iterator::key(), rocksdb::Options::max_background_compactions, rocksdb::Options::memtable_factory, NewBloomFilterPolicy(), NewFixedPrefixTransform(), NewHashSkipListRepFactory(), rocksdb::DBImpl::NewIterator(), rocksdb::Iterator::Next(), rocksdb::Options::no_block_cache, std::chrono::prefix, rocksdb::ReadOptions::prefix, rocksdb::Options::prefix_extractor, PrefixScanInit(), rocksdb::Iterator::SeekToFirst(), rocksdb::Slice::starts_with(), rocksdb::Iterator::status(), rocksdb::Iterator::Valid(), and rocksdb::Options::whole_key_filtering.

                         {
  for (int it = 0; it < 2; ++it) {
    ReadOptions ro = ReadOptions();
    int count;
    Slice prefix;
    Slice key;
    char buf[100];
    Iterator* iter;
    snprintf(buf, sizeof(buf), "03______:");
    prefix = Slice(buf, 8);
    key = Slice(buf, 9);
    auto prefix_extractor = NewFixedPrefixTransform(8);
    // db configs
    env_->count_random_reads_ = true;
    Options options = CurrentOptions();
    options.env = env_;
    options.no_block_cache = true;
    options.filter_policy =  NewBloomFilterPolicy(10);
    options.prefix_extractor = prefix_extractor;
    options.whole_key_filtering = false;
    options.disable_auto_compactions = true;
    options.max_background_compactions = 2;
    options.create_if_missing = true;
    options.disable_seek_compaction = true;
    if (it == 0) {
      options.memtable_factory.reset(NewHashSkipListRepFactory(
            prefix_extractor));
    } else {
      options.memtable_factory = std::make_shared<PrefixHashRepFactory>(
          prefix_extractor);
    }

    // prefix specified, with blooms: 2 RAND I/Os
    // SeekToFirst
    DestroyAndReopen(&options);
    PrefixScanInit(this);
    count = 0;
    env_->random_read_counter_.Reset();
    ro.prefix = &prefix;
    iter = db_->NewIterator(ro);
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      assert(iter->key().starts_with(prefix));
      count++;
    }
    ASSERT_OK(iter->status());
    delete iter;
    ASSERT_EQ(count, 2);
    ASSERT_EQ(env_->random_read_counter_.Read(), 2);

    // prefix specified, with blooms: 2 RAND I/Os
    // Seek
    DestroyAndReopen(&options);
    PrefixScanInit(this);
    count = 0;
    env_->random_read_counter_.Reset();
    ro.prefix = &prefix;
    iter = db_->NewIterator(ro);
    for (iter->Seek(key); iter->Valid(); iter->Next()) {
      assert(iter->key().starts_with(prefix));
      count++;
    }
    ASSERT_OK(iter->status());
    delete iter;
    ASSERT_EQ(count, 2);
    ASSERT_EQ(env_->random_read_counter_.Read(), 2);

    // no prefix specified: 11 RAND I/Os
    DestroyAndReopen(&options);
    PrefixScanInit(this);
    count = 0;
    env_->random_read_counter_.Reset();
    iter = db_->NewIterator(ReadOptions());
    for (iter->Seek(prefix); iter->Valid(); iter->Next()) {
      if (! iter->key().starts_with(prefix)) {
        break;
      }
      count++;
    }
    ASSERT_OK(iter->status());
    delete iter;
    ASSERT_EQ(count, 2);
    ASSERT_EQ(env_->random_read_counter_.Read(), 11);
    Close();
    delete options.filter_policy;
  }
}

Here is the call graph for this function:

static void rocksdb::TestEncodeDecode ( const VersionEdit &  edit)

static

Definition at line 15 of file version_edit_test.cc.

References ASSERT_EQ, ASSERT_TRUE, rocksdb::VersionEdit::DecodeFrom(), rocksdb::VersionEdit::EncodeTo(), rocksdb::Status::ok(), and rocksdb::Status::ToString().

Referenced by TEST().

                                                      {
  std::string encoded, encoded2;
  edit.EncodeTo(&encoded);
  VersionEdit parsed(7);
  Status s = parsed.DecodeFrom(encoded);
  ASSERT_TRUE(s.ok()) << s.ToString();
  parsed.EncodeTo(&encoded2);
  ASSERT_EQ(encoded, encoded2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rocksdb::TestKey ( const std::string &  key, uint64_t  seq, ValueType  vt  )

static

Definition at line 36 of file dbformat_test.cc.

References ASSERT_EQ, ASSERT_TRUE, IKey(), Json::in(), kTypeValue, ParseInternalKey(), rocksdb::ParsedInternalKey::sequence, rocksdb::Slice::ToString(), rocksdb::ParsedInternalKey::type, and rocksdb::ParsedInternalKey::user_key.

Referenced by rocksdb::TestKeyComparator::Compare(), and TEST().

                                  {
  std::string encoded = IKey(key, seq, vt);

  Slice in(encoded);
  ParsedInternalKey decoded("", 0, kTypeValue);

  ASSERT_TRUE(ParseInternalKey(in, &decoded));
  ASSERT_EQ(key, decoded.user_key.ToString());
  ASSERT_EQ(seq, decoded.sequence);
  ASSERT_EQ(vt, decoded.type);

  ASSERT_TRUE(!ParseInternalKey(Slice("bar"), &decoded));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Slice rocksdb::TestKeyToSlice ( const TestKey &  test_key)

inline

Definition at line 39 of file prefix_test.cc.

Referenced by TEST().

                                                     {
  return Slice((const char*)&test_key, sizeof(test_key));
}

Here is the caller graph for this function:

static void rocksdb::ThreadBody ( void *  arg)

static

Definition at line 83 of file env_test.cc.

References arg, rocksdb::port::Mutex::Lock(), rocksdb::State::mu, rocksdb::State::num_running, rocksdb::port::Mutex::Unlock(), and rocksdb::State::val.

Referenced by TEST().

                                  {
  State* s = reinterpret_cast<State*>(arg);
  s->mu.Lock();
  s->val += 1;
  s->num_running -= 1;
  s->mu.Unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static uint64_t rocksdb::TotalFileSize ( const std::vector< FileMetaData * > &  files)

static

Definition at line 31 of file version_set.cc.

Referenced by rocksdb::VersionSet::Finalize(), rocksdb::Compaction::IsTrivialMove(), rocksdb::VersionSet::MaxNextLevelOverlappingBytes(), rocksdb::VersionSet::NumLevelBytes(), rocksdb::VersionSet::PickCompactionUniversalReadAmp(), rocksdb::Version::PickLevelForMemTableOutput(), and rocksdb::VersionSet::SetupOtherInputs().

                                                                     {
  uint64_t sum = 0;
  for (size_t i = 0; i < files.size() && files[i]; i++) {
    sum += files[i]->file_size;
  }
  return sum;
}

Here is the caller graph for this function:

Status rocksdb::UncompressBlockContents	(	const char *	data,
		size_t	n,
		BlockContents *	result
	)

Definition at line 151 of file format.cc.

References rocksdb::port::BZip2_Uncompress(), rocksdb::BlockContents::cachable, rocksdb::BlockContents::compression_type, rocksdb::Status::Corruption(), rocksdb::BlockContents::data, rocksdb::BlockContents::heap_allocated, kBZip2Compression, kNoCompression, kSnappyCompression, kZlibCompression, rocksdb::Status::OK(), rocksdb::port::Snappy_GetUncompressedLength(), rocksdb::port::Snappy_Uncompress(), and rocksdb::port::Zlib_Uncompress().

Referenced by rocksdb::BlockBasedTable::BlockReader(), and ReadBlockContents().

                                                      {
  char* ubuf = nullptr;
  int decompress_size = 0;
  assert(data[n] != kNoCompression);
  switch (data[n]) {
    case kSnappyCompression: {
      size_t ulength = 0;
      static char snappy_corrupt_msg[] =
        "Snappy not supported or corrupted Snappy compressed block contents";
      if (!port::Snappy_GetUncompressedLength(data, n, &ulength)) {
        return Status::Corruption(snappy_corrupt_msg);
      }
      ubuf = new char[ulength];
      if (!port::Snappy_Uncompress(data, n, ubuf)) {
        delete[] ubuf;
        return Status::Corruption(snappy_corrupt_msg);
      }
      result->data = Slice(ubuf, ulength);
      result->heap_allocated = true;
      result->cachable = true;
      break;
    }
    case kZlibCompression:
      ubuf = port::Zlib_Uncompress(data, n, &decompress_size);
      static char zlib_corrupt_msg[] =
        "Zlib not supported or corrupted Zlib compressed block contents";
      if (!ubuf) {
        return Status::Corruption(zlib_corrupt_msg);
      }
      result->data = Slice(ubuf, decompress_size);
      result->heap_allocated = true;
      result->cachable = true;
      break;
    case kBZip2Compression:
      ubuf = port::BZip2_Uncompress(data, n, &decompress_size);
      static char bzip2_corrupt_msg[] =
        "Bzip2 not supported or corrupted Bzip2 compressed block contents";
      if (!ubuf) {
        return Status::Corruption(bzip2_corrupt_msg);
      }
      result->data = Slice(ubuf, decompress_size);
      result->heap_allocated = true;
      result->cachable = true;
      break;
    default:
      return Status::Corruption("bad block type");
  }
  result->compression_type = kNoCompression; // not compressed any more
  return Status::OK();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rocksdb::UnrefEntry ( void *  arg1, void *  arg2  )

static

Definition at line 26 of file table_cache.cc.

References rocksdb::Cache::Release().

Referenced by rocksdb::TableCache::NewIterator().

                                               {
  Cache* cache = reinterpret_cast<Cache*>(arg1);
  Cache::Handle* h = reinterpret_cast<Cache::Handle*>(arg2);
  cache->Release(h);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rocksdb::UpdateInternalKey ( char *  internal_key, const size_t  internal_key_size, uint64_t  seq, ValueType  t  )

inline

Definition at line 171 of file dbformat.h.

References EncodeFixed64().

Referenced by rocksdb::DBImpl::DoCompactionWork(), and rocksdb::MergeHelper::MergeUntil().

                                                         {
  assert(internal_key_size >= 8);
  char* seqtype = internal_key + internal_key_size - 8;
  uint64_t newval = (seq << 8) | t;
  EncodeFixed64(seqtype, newval);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rocksdb::VarintLength

(

uint64_t

v)

Definition at line 122 of file coding.cc.

Referenced by rocksdb::MemTable::Add(), rocksdb::BlockBuilder::EstimateSizeAfterKV(), TEST(), and rocksdb::MemTable::Update().

                             {
  int len = 1;
  while (v >= 128) {
    v >>= 7;
    len++;
  }
  return len;
}

Here is the caller graph for this function:

rocksdb::verbose_

(

false

)

Referenced by path_().

Here is the caller graph for this function:

Status rocksdb::WriteStringToFile	(	Env *	env,
		const Slice &	data,
		const std::string &	fname
	)

Definition at line 82 of file env.cc.

References DoWriteStringToFile().

Referenced by rocksdb::CorruptionTest::Corrupt().

                                                 {
  return DoWriteStringToFile(env, data, fname, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Status rocksdb::WriteStringToFileSync	(	Env *	env,
		const Slice &	data,
		const std::string &	fname
	)

Definition at line 87 of file env.cc.

References DoWriteStringToFile().

Referenced by SetCurrentFile(), and SetIdentityFile().

                                                     {
  return DoWriteStringToFile(env, data, fname, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::ZlibCompressionSupported ( const CompressionOptions &  options)

static

Definition at line 40 of file db_test.cc.

References rocksdb::Slice::data(), Json::in(), rocksdb::Slice::size(), and rocksdb::port::Zlib_Compress().

Referenced by GenerateArgList(), MinLevelToCompress(), and TEST().

                                                                        {
  std::string out;
  Slice in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  return port::Zlib_Compress(options, in.data(), in.size(), &out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool rocksdb::ZlibCompressionSupported ( )

static

Definition at line 460 of file table_test.cc.

References rocksdb::Slice::data(), Json::in(), rocksdb::Slice::size(), and rocksdb::port::Zlib_Compress().

                                       {
  std::string out;
  Slice in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  return port::Zlib_Compress(Options().compression_opts,
                             in.data(), in.size(),
                             &out);
}

Here is the call graph for this function:

Variable Documentation

const char* const rocksdb::access_hints[]

static

Initial value:

= {
  "NONE", "NORMAL", "SEQUENTIAL", "WILLNEED"
}

Definition at line 108 of file options.cc.

Referenced by rocksdb::Options::Dump().

const std::string rocksdb::ARCHIVAL_DIR = "archive"

static

Definition at line 41 of file filename.h.

Referenced by ArchivalDirectory(), ArchivedLogFileName(), and ParseFileName().

const Comparator* rocksdb::bytewise

static

Definition at line 75 of file comparator.cc.

Referenced by BytewiseComparator(), and InitModule().

int rocksdb::cfilter_count

static

Definition at line 2536 of file db_test.cc.

Referenced by rocksdb::KeepFilter::Filter(), rocksdb::DeleteFilter::Filter(), and TEST().

rocksdb::else

Initial value:

{
    key_ = params.at(0)

Definition at line 1362 of file ldb_cmd.cc.

const std::vector<std::pair<Histograms, std::string> > rocksdb::HistogramsNameMap

Initial value:

= {
  { DB_GET, "rocksdb.db.get.micros" },
  { DB_WRITE, "rocksdb.db.write.micros" },
  { COMPACTION_TIME, "rocksdb.compaction.times.micros" },
  { TABLE_SYNC_MICROS, "rocksdb.table.sync.micros" },
  { COMPACTION_OUTFILE_SYNC_MICROS, "rocksdb.compaction.outfile.sync.micros" },
  { WAL_FILE_SYNC_MICROS, "rocksdb.wal.file.sync.micros" },
  { MANIFEST_FILE_SYNC_MICROS, "rocksdb.manifest.file.sync.micros" },
  { TABLE_OPEN_IO_MICROS, "rocksdb.table.open.io.micros" },
  { DB_MULTIGET, "rocksdb.db.multiget.micros" },
  { READ_BLOCK_COMPACTION_MICROS, "rocksdb.read.block.compaction.micros" },
  { READ_BLOCK_GET_MICROS, "rocksdb.read.block.get.micros" },
  { WRITE_RAW_BLOCK_MICROS, "rocksdb.write.raw.block.micros" },
  { STALL_L0_SLOWDOWN_COUNT, "rocksdb.l0.slowdown.count"},
  { STALL_MEMTABLE_COMPACTION_COUNT, "rocksdb.memtable.compaction.count"},
  { STALL_L0_NUM_FILES_COUNT, "rocksdb.num.files.stall.count"},
  { HARD_RATE_LIMIT_DELAY_COUNT, "rocksdb.hard.rate.limit.delay.count"},
  { SOFT_RATE_LIMIT_DELAY_COUNT, "rocksdb.soft.rate.limit.delay.count"},
  { NUM_FILES_IN_SINGLE_COMPACTION, "rocksdb.numfiles.in.singlecompaction" },
}

Definition at line 189 of file statistics.h.

Referenced by RecordTick(), SetTickerCount(), and rocksdb::Statistics::ToString().

const size_t rocksdb::kBlockTrailerSize = 5

static

Definition at line 88 of file format.h.

Referenced by rocksdb::BlockBasedTableBuilder::Finish(), ReadBlockContents(), TEST(), and rocksdb::BlockBasedTableBuilder::WriteRawBlock().

const std::string rocksdb::kDbName = "/tmp/mergetestdb"

Definition at line 26 of file stringappend_test.cc.

Referenced by OpenDb(), rocksdb::PrefixTest::OpenDb(), OpenNormalDb(), OpenTtlDb(), ProfileKeyComparison(), rocksdb::StringAppendOperatorTest::StringAppendOperatorTest(), and TEST().

const int rocksdb::kDebugLogChunkSize = 128 * 1024

Definition at line 28 of file posix_logger.h.

Referenced by rocksdb::PosixLogger::Logv().

const int rocksdb::kDelayMicros = 100000

static

Definition at line 22 of file env_test.cc.

Referenced by TEST().

const size_t rocksdb::kFilterBase = 1 << kFilterBaseLg

static

Definition at line 22 of file filter_block.cc.

Referenced by rocksdb::FilterBlockBuilder::StartBlock().

const size_t rocksdb::kFilterBaseLg = 11

static

Definition at line 21 of file filter_block.cc.

Referenced by rocksdb::FilterBlockBuilder::Finish().

const size_t rocksdb::kHeader = 12

static

Definition at line 37 of file write_batch.cc.

Referenced by rocksdb::WriteBatchInternal::Append(), rocksdb::WriteBatch::Clear(), rocksdb::WriteBatch::Iterate(), and rocksdb::WriteBatchInternal::SetContents().

const int rocksdb::kMajorVersion = 2

static

Definition at line 26 of file db.h.

Referenced by rocksdb::DBImpl::LogDBDeployStats(), rocksdb::StressTest::PrintEnv(), and rocksdb::Benchmark::PrintEnvironment().

const size_t rocksdb::kMaxCacheKeyPrefixSize = kMaxVarint64Length*3+1

Definition at line 35 of file block_based_table_reader.cc.

const SequenceNumber rocksdb::kMaxSequenceNumber

static

Initial value:

=
    ((0x1ull << 56) - 1)

Definition at line 44 of file dbformat.h.

Referenced by rocksdb::DBTest::AllEntriesFor(), rocksdb::InternalDumpCommand::DoCommand(), rocksdb::DBImpl::DoCompactionWork(), rocksdb::InternalKeyComparator::FindShortestSeparator(), rocksdb::InternalKeyComparator::FindShortSuccessor(), rocksdb::DBImpl::GetApproximateSizes(), PackSequenceAndType(), rocksdb::Version::PickLevelForMemTableOutput(), rocksdb::SstFileReader::ReadSequential(), rocksdb::KeyConvertingIterator::Seek(), SomeFileOverlapsRange(), TEST(), and rocksdb::DBImpl::TEST_CompactRange().

const unsigned int rocksdb::kMaxVarint32Length = 5

Definition at line 24 of file coding.h.

const unsigned int rocksdb::kMaxVarint64Length = 10

Definition at line 25 of file coding.h.

Referenced by rocksdb::BlockBasedTable::BlockReader(), rocksdb::BlockBasedTable::GetBlock(), and rocksdb::BlockBasedTable::GetFilter().

const int rocksdb::kMinorVersion = 0

static

Definition at line 27 of file db.h.

Referenced by rocksdb::DBImpl::LogDBDeployStats(), rocksdb::StressTest::PrintEnv(), and rocksdb::Benchmark::PrintEnvironment().

const uint64_t rocksdb::kTableMagicNumber = 0xdb4775248b80fb57ull

static

Definition at line 85 of file format.h.

Referenced by rocksdb::Footer::DecodeFrom(), and rocksdb::Footer::EncodeTo().

const int rocksdb::kValueSize = 1000

static

Definition at line 30 of file corruption_test.cc.

Referenced by TEST(), and rocksdb::CorruptionTest::Value().

const ValueType rocksdb::kValueTypeForSeek = kTypeMerge

static

Definition at line 40 of file dbformat.h.

Referenced by rocksdb::InternalDumpCommand::DoCommand(), rocksdb::InternalKeyComparator::FindShortestSeparator(), rocksdb::InternalKeyComparator::FindShortSuccessor(), rocksdb::DBImpl::GetApproximateSizes(), rocksdb::LookupKey::LookupKey(), PackSequenceAndType(), ParseInternalKey(), rocksdb::Version::PickLevelForMemTableOutput(), rocksdb::SstFileReader::ReadSequential(), SomeFileOverlapsRange(), TEST(), and rocksdb::DBImpl::TEST_CompactRange().

const int rocksdb::kVerbose = 1

static

Definition at line 18 of file bloom_test.cc.

Referenced by rocksdb::BloomTest::Build(), TEST(), and rocksdb::Harness::TestRandomAccess().

std::string rocksdb::NEW_VALUE = "NewValue"

static

Definition at line 2537 of file db_test.cc.

Referenced by rocksdb::ChangeFilter::Filter(), and TEST().

const Status rocksdb::notsup

static

Definition at line 213 of file env_hdfs.h.

Referenced by rocksdb::HdfsEnv::CreateDir(), rocksdb::HdfsEnv::CreateDirIfMissing(), rocksdb::HdfsEnv::DeleteDir(), rocksdb::HdfsEnv::DeleteFile(), rocksdb::HdfsEnv::GetAbsolutePath(), rocksdb::HdfsEnv::GetChildren(), rocksdb::HdfsEnv::GetCurrentTime(), rocksdb::HdfsEnv::GetFileModificationTime(), rocksdb::HdfsEnv::GetFileSize(), rocksdb::HdfsEnv::GetHostName(), rocksdb::HdfsEnv::GetTestDirectory(), rocksdb::HdfsEnv::LockFile(), rocksdb::HdfsEnv::NewLogger(), rocksdb::HdfsEnv::NewRandomAccessFile(), rocksdb::HdfsEnv::NewRandomRWFile(), rocksdb::HdfsEnv::NewWritableFile(), rocksdb::HdfsEnv::RenameFile(), and rocksdb::HdfsEnv::UnlockFile().

port::OnceType rocksdb::once = LEVELDB_ONCE_INIT

static

Definition at line 74 of file comparator.cc.

Referenced by BytewiseComparator(), sqlite3VdbeExec(), and whereLoopAddOr().

__thread PerfContext rocksdb::perf_context

Definition at line 28 of file perf_context.cc.

Referenced by rocksdb::BlockBasedTable::BlockReader(), rocksdb::InternalKeyComparator::Compare(), ProfileKeyComparison(), ReadBlockContents(), TEST(), and rocksdb::DBImpl::Write().

enum PerfLevel rocksdb::perf_level = kEnableCount

Definition at line 11 of file perf_context.cc.

Referenced by BumpPerfCount(), BumpPerfTime(), SetPerfLevel(), and StartPerfTimer().

ReverseKeyComparator rocksdb::reverse_key_comparator

static

Definition at line 74 of file table_test.cc.

Referenced by Increment(), and rocksdb::Harness::Init().

const std::vector<std::pair<Tickers, std::string> > rocksdb::TickersNameMap

Initial value:

= {
  { BLOCK_CACHE_MISS, "rocksdb.block.cache.miss" },
  { BLOCK_CACHE_HIT, "rocksdb.block.cache.hit" },
  { BLOCK_CACHE_ADD, "rocksdb.block.cache.add" },
  { BLOCK_CACHE_INDEX_MISS, "rocksdb.block.cache.index.miss" },
  { BLOCK_CACHE_INDEX_HIT, "rocksdb.block.cache.index.hit" },
  { BLOCK_CACHE_FILTER_MISS, "rocksdb.block.cache.filter.miss" },
  { BLOCK_CACHE_FILTER_HIT, "rocksdb.block.cache.filter.hit" },
  { BLOCK_CACHE_DATA_MISS, "rocksdb.block.cache.data.miss" },
  { BLOCK_CACHE_DATA_HIT, "rocksdb.block.cache.data.hit" },
  { BLOOM_FILTER_USEFUL, "rocksdb.bloom.filter.useful" },
  { COMPACTION_KEY_DROP_NEWER_ENTRY, "rocksdb.compaction.key.drop.new" },
  { COMPACTION_KEY_DROP_OBSOLETE, "rocksdb.compaction.key.drop.obsolete" },
  { COMPACTION_KEY_DROP_USER, "rocksdb.compaction.key.drop.user" },
  { NUMBER_KEYS_WRITTEN, "rocksdb.number.keys.written" },
  { NUMBER_KEYS_READ, "rocksdb.number.keys.read" },
  { NUMBER_KEYS_UPDATED, "rocksdb.number.keys.updated" },
  { BYTES_WRITTEN, "rocksdb.bytes.written" },
  { BYTES_READ, "rocksdb.bytes.read" },
  { NO_FILE_CLOSES, "rocksdb.no.file.closes" },
  { NO_FILE_OPENS, "rocksdb.no.file.opens" },
  { NO_FILE_ERRORS, "rocksdb.no.file.errors" },
  { STALL_L0_SLOWDOWN_MICROS, "rocksdb.l0.slowdown.micros" },
  { STALL_MEMTABLE_COMPACTION_MICROS, "rocksdb.memtable.compaction.micros" },
  { STALL_L0_NUM_FILES_MICROS, "rocksdb.l0.num.files.stall.micros" },
  { RATE_LIMIT_DELAY_MILLIS, "rocksdb.rate.limit.delay.millis" },
  { NO_ITERATORS, "rocksdb.num.iterators" },
  { NUMBER_MULTIGET_CALLS, "rocksdb.number.multiget.get" },
  { NUMBER_MULTIGET_KEYS_READ, "rocksdb.number.multiget.keys.read" },
  { NUMBER_MULTIGET_BYTES_READ, "rocksdb.number.multiget.bytes.read" },
  { NUMBER_FILTERED_DELETES, "rocksdb.number.deletes.filtered" },
  { NUMBER_MERGE_FAILURES, "rocksdb.number.merge.failures" },
  { SEQUENCE_NUMBER, "rocksdb.sequence.number" },
  { BLOOM_FILTER_PREFIX_CHECKED, "rocksdb.bloom.filter.prefix.checked" },
  { BLOOM_FILTER_PREFIX_USEFUL, "rocksdb.bloom.filter.prefix.useful" },
  { NUMBER_OF_RESEEKS_IN_ITERATION, "rocksdb.number.reseeks.iteration" },
  { GET_UPDATES_SINCE_CALLS, "rocksdb.getupdatessince.calls" },
  { BLOCK_CACHE_COMPRESSED_MISS, "rocksdb.block.cachecompressed.miss" },
  { BLOCK_CACHE_COMPRESSED_HIT, "rocksdb.block.cachecompressed.hit" }
}

Definition at line 117 of file statistics.h.

Referenced by RecordTick(), SetTickerCount(), and rocksdb::Statistics::ToString().